{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(FeedForwardNeuralNetworks)=\n",
    "# Feed-forward neural network"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As neural networks are a pillar in both the early and the recent advances of artificial intelligence, their use for credit card fraud detection is not surprising. The first examples of simple feed-forward neural networks applied to fraud detection can bring us back to the early 90s {cite}`ghosh1994credit,aleskerov1997cardwatch`. Naturally, in recent FDS studies, neural networks are often found in experimental benchmarks, along with random forests, XGBoost, or logistic regression. \n",
    "\n",
    "At the core of a feed-forward neural network is the artificial neuron, a simple machine learning model that consists of a linear combination of input variables followed by the application of an activation function $\\sigma$ (sigmoid, ReLU, tanh, ...). More precisely, given a list of $n$ input variables $x_i$, the output $h$ of the artificial neuron is computed as follows:\n",
    "\n",
    "$h = \\sigma(\\sum_{i=1}^n w_i*x_i)$\n",
    "\n",
    "where $w_i$ are the weights of the model.\n",
    "\n",
    "A whole network is composed of a succession of layers containing neurons that take, as inputs, the output values of the previous layer.\n",
    "\n",
    "![A feed forward neural network architecture](./images/neuralnetwork.png)\n",
    "\n",
    "When applied to the fraud detection problem, the architecture is designed as follows:\n",
    "\n",
    "* At the beginning of the network, the neurons take as input the characteristics of a credit card transaction, i.e. the features that were defined in the previous chapters.\n",
    "* At the end, the network outputs a single neuron that aims at representing the probability for the input transaction to be a fraud. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The rest of the architecture (other layers), the neurons specificity (activation functions), and other hyperparameters (optimization, data processing, ...) are left to the practitioner's choice. \n",
    "\n",
    "The most popular training algorithm for feedforward architectures is backpropagation {cite}`hecht1992theory`. The idea is to iterate over all samples of the dataset and perform two key operations: \n",
    "* the forward pass: setting the sample's features values in the input neurons and computing all the layers to finally obtain a predicted output.\n",
    "* the backward pass: computing a cost function, i.e. a discrepancy between the prediction and the expected ground truth output, and trying to minimize it with an optimizer (e.g. gradient descent) by updating weights layer after layer, from output to input. \n",
    "\n",
    "This section covers the design of a feed-foward neural network for fraud detection. It describes how to:\n",
    "* Implement a first simple neural network and study the impact of several architectures and design choices.\n",
    "* Wrap it to make it compatible with the model selection methodology from Chapter 5 and run a grid-search to select its optimal parameters.\n",
    "* Store the important functions for a final comparison between deep learning techniques and other baselines at the end of the chapter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us first start by importing all the necessary libraries and functions and retrieving the simulated data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true,
    "tags": [
     "hide-cell"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
      "                                 Dload  Upload   Total   Spent    Left  Speed\n",
      "100 63257  100 63257    0     0   225k      0 --:--:-- --:--:-- --:--:--  227k\n"
     ]
    }
   ],
   "source": [
    "# Initialization: Load shared functions and simulated data \n",
    "\n",
    "# Load shared functions\n",
    "!curl -O https://raw.githubusercontent.com/Fraud-Detection-Handbook/fraud-detection-handbook/main/Chapter_References/shared_functions.py\n",
    "%run shared_functions.py\n",
    "\n",
    "# Get simulated data from Github repository\n",
    "if not os.path.exists(\"simulated-data-transformed\"):\n",
    "    !git clone https://github.com/Fraud-Detection-Handbook/simulated-data-transformed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Loading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The experimental setup is the same as in Chapter 5. More precisely, at the end of the chapter, model selection will be based on a grid search with multiple validations. Each time, one week of data will be used for training a neural network and one week of data for testing the predictions.\n",
    "\n",
    "To implement the first base network and explore several architecture choices, let us start by selecting a training and validation period arbitrarily. The experiments will be based on the transformed simulated data (`simulated-data-transformed/data/`) and the same feature set as other models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Load  files\n",
      "CPU times: user 321 ms, sys: 245 ms, total: 566 ms\n",
      "Wall time: 588 ms\n",
      "919767 transactions loaded, containing 8195 fraudulent transactions\n"
     ]
    }
   ],
   "source": [
    "DIR_INPUT='simulated-data-transformed/data/' \n",
    "\n",
    "BEGIN_DATE = \"2018-06-11\"\n",
    "END_DATE = \"2018-09-14\"\n",
    "\n",
    "print(\"Load  files\")\n",
    "%time transactions_df=read_from_files(DIR_INPUT, BEGIN_DATE, END_DATE)\n",
    "print(\"{0} transactions loaded, containing {1} fraudulent transactions\".format(len(transactions_df),transactions_df.TX_FRAUD.sum()))\n",
    "\n",
    "output_feature=\"TX_FRAUD\"\n",
    "\n",
    "input_features=['TX_AMOUNT','TX_DURING_WEEKEND', 'TX_DURING_NIGHT', 'CUSTOMER_ID_NB_TX_1DAY_WINDOW',\n",
    "       'CUSTOMER_ID_AVG_AMOUNT_1DAY_WINDOW', 'CUSTOMER_ID_NB_TX_7DAY_WINDOW',\n",
    "       'CUSTOMER_ID_AVG_AMOUNT_7DAY_WINDOW', 'CUSTOMER_ID_NB_TX_30DAY_WINDOW',\n",
    "       'CUSTOMER_ID_AVG_AMOUNT_30DAY_WINDOW', 'TERMINAL_ID_NB_TX_1DAY_WINDOW',\n",
    "       'TERMINAL_ID_RISK_1DAY_WINDOW', 'TERMINAL_ID_NB_TX_7DAY_WINDOW',\n",
    "       'TERMINAL_ID_RISK_7DAY_WINDOW', 'TERMINAL_ID_NB_TX_30DAY_WINDOW',\n",
    "       'TERMINAL_ID_RISK_30DAY_WINDOW']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting the starting day for the training period, and the deltas\n",
    "start_date_training = datetime.datetime.strptime(\"2018-07-25\", \"%Y-%m-%d\")\n",
    "delta_train=7\n",
    "delta_delay=7\n",
    "delta_test=7\n",
    "(train_df, test_df)=get_train_test_set(transactions_df,start_date_training,\n",
    "                                       delta_train=delta_train,delta_delay=delta_delay,delta_test=delta_test)\n",
    "# By default, scaling the input data\n",
    "(train_df, test_df)=scaleData(train_df,test_df,input_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Overview of the neural network pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first step here is to implement a base neural network. There are several Python libraries that we can use (TensorFlow, PyTorch, Keras, MXNet, ...). In this book, the PyTorch library {cite}`paszke2017automatic` is used, but the models and benchmarks that will be developed could also be implemented with other libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If torch and cuda libraries are installed properly, the models developed in this chapter can be trained on the GPU. For that, let us create a \"DEVICE\" variable and set it to \"cuda\" if a cuda device is available and \"cpu\" otherwise. In the rest of the chapter, all the models and tensors will be sent to this device for computations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Selected device is cuda\n"
     ]
    }
   ],
   "source": [
    "if torch.cuda.is_available():\n",
    "    DEVICE = \"cuda\" \n",
    "else:\n",
    "    DEVICE = \"cpu\"\n",
    "print(\"Selected device is\",DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To ensure reproducibility, a random seed will be fixed like in previous chapters. Additionally to setting the seed for `NumPy` and `random`, it is necessary to set it for `torch`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "SEED = 42\n",
    "\n",
    "def seed_everything(seed):\n",
    "    random.seed(seed)\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed(seed)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = True\n",
    "\n",
    "seed_everything(SEED)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `seed_everything` defined above will be run before each model initialization and training."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before diving into the neural network implementation, let us summarize the main elements of a deep learning training/testing pipeline in Torch:\n",
    "* Datasets/Dataloaders: It is recommended to manipulate data with specific PyTorch classes. [Dataset](https://pytorch.org/docs/stable/data.html?highlight=dataset#torch.utils.data.Dataset) is the interface to access the data. Given a sample's index, it provides a well-formed input-output for the model. [Dataloader](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader) takes the Dataset as input and provides an iterator for the training loop. It also allows to create batches, shuffle data, and parallelize data preparation. \n",
    "* Model/Module: Any model in PyTorch is a [torch.module](https://pytorch.org/docs/stable/generated/torch.nn.Module.html). It has an init function in which it instantiates all the necessary submodules (layers) and initializes their weights. It also has a forward function that defines all the operations of the forward pass. \n",
    "* The optimizer: The [optimizer](https://pytorch.org/docs/stable/optim.html) is the object that implements the optimization algorithm. It is called after the loss is computed to calculate the necessary model updates. The most basic one is SGD, but there are many others like RMSProp, Adagrad, Adam, ...\n",
    "* Training loop and evaluation: the training loop is the core of a model's training. It consists in performing several iterations (epochs), getting all the training batches from the loader, performing the forward pass, computing the loss, and calling the optimizer. After each epoch, an evaluation can be performed to track the model's evolution and possibly stop the process.\n",
    "\n",
    "The next subsections describe and implement in details each of these elements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data management: Datasets and Dataloaders"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first step is to convert our data into objects that PyTorch can use, like `FloatTensors`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_train = torch.FloatTensor(train_df[input_features].values)\n",
    "x_test = torch.FloatTensor(test_df[input_features].values)\n",
    "y_train = torch.FloatTensor(train_df[output_feature].values)\n",
    "y_test = torch.FloatTensor(test_df[output_feature].values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next comes the definition of a custom `Dataset`. This dataset is initialized with `x_train`/`x_test` and `y_train`/`y_test` and returns the individual samples in the format required by our model, after sending them to the right device. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FraudDataset(torch.utils.data.Dataset):\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        'Initialization'\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __len__(self):\n",
    "        'Returns the total number of samples'\n",
    "        return len(self.x)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generates one sample of data'\n",
    "        # Select sample index\n",
    "        if self.y is not None:\n",
    "            return self.x[index].to(DEVICE), self.y[index].to(DEVICE)\n",
    "        else:\n",
    "            return self.x[index].to(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: This first custom Dataset `FraudDataset` seems useless because its role is very limited (simply returning a row from x and y) and because the matrices x and y are already loaded in RAM. This example is provided for educational purposes. But the concept of Dataset has a high interest when sample preparation requires more preprocessing. For instance, it becomes very handy for sequence preparation when using recurrent models (like an LSTM). This will be covered more in-depth later in this chapter but for example, a Dataset for sequential models performs several operations before returning a sample: searching for the history of transactions of the same cardholder and appending it to the current transaction before returning the whole sequence. It avoids preparing all the sequences in advance, which would entail repeating several transactions' features in memory and consuming more RAM than necessary. Datasets objects are also useful when dealing with large image datasets in order to load the images on the fly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that `FraudDataset` is defined, one can choose the training/evaluation parameters and instantiate DataLoaders. For now, let us consider a batch size of 64: this means that at each optimization step, 64 samples will be requested to the Dataset, turned into a batch, and go through the forward pass in parallel. Then the aggregation (sum or average) of the gradient of their losses will be used for backpropagation. \n",
    "\n",
    "For the training DataLoader, the shuffle option will be set to `True` so that the order of the data seen by the model will not be the same from one epoch to another. This is recommended and known to be beneficial in Neural Network training {cite}`ruder2016overview`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader_params = {'batch_size': 64,\n",
    "          'shuffle': True,\n",
    "          'num_workers': 0}\n",
    "test_loader_params = {'batch_size': 64,\n",
    "          'num_workers': 0}\n",
    "\n",
    "# Generators\n",
    "\n",
    "training_set = FraudDataset(x_train, y_train)\n",
    "\n",
    "testing_set = FraudDataset(x_test, y_test)\n",
    "\n",
    "\n",
    "training_generator = torch.utils.data.DataLoader(training_set, **train_loader_params)\n",
    "testing_generator = torch.utils.data.DataLoader(testing_set, **test_loader_params)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `num_workers` parameter allows parallelizing batch preparation. It can be useful when the `Dataset` requires a lot of processing before returning a sample. Here we do not use multiprocessing so we set `num_workers` to 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The model aka the module\n",
    "\n",
    "After defining the data pipeline, the next step is to design the module. Let us start with a first rather simple feed-forward neural network. \n",
    "\n",
    "As suggested in the introduction, the idea is to define several fully connected layers (`torch.nn.Linear`). A first layer `fc1` which takes as input as many neurons as there are features in the input x. It can be followed by a hidden layer with a chosen number of neurons (`hidden_size`). Finally comes the output layer which has a single output neuron to fit the label (`fraud` or `genuine`, represented by 1 and 0). \n",
    "\n",
    "In the past, the sigmoid activation function used to be the primary choice for all activation functions in all layers of a neural network. Today, the preferred choice is `ReLU` (or variants like `eLU`, `leaky ReLU`), at least for the intermediate neurons. It has empirically proven to be a better choice for optimization and speed {cite}`nair2010rectified`. For output neurons, the choice depends on the range or the expected distribution for the output value to be predicted.\n",
    "\n",
    "Below are plotted the output of several activation functions with respect to their input value to show how they behave and how they are distributed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": [
     "hide-cell"
    ]
   },
   "outputs": [],
   "source": [
    "%%capture\n",
    "\n",
    "fig_activation, axs = plt.subplots(3, 2,figsize=(11, 13))\n",
    "\n",
    "input_values = torch.arange(-5, 5, 0.05)\n",
    "\n",
    "#linear activation\n",
    "output_values = input_values\n",
    "axs[0, 0].plot(input_values, output_values)\n",
    "axs[0, 0].set_title('Linear')\n",
    "axs[0, 0].set_ylim([-5.1,5.1])\n",
    "\n",
    "#heavyside activation\n",
    "output_values = input_values>0\n",
    "axs[0, 1].plot(input_values, output_values)\n",
    "axs[0, 1].set_title('Heavyside (perceptron)')\n",
    "axs[0, 1].set_ylim([-0.1,1.1])\n",
    "\n",
    "#sigmoid activation\n",
    "activation = torch.nn.Sigmoid()\n",
    "output_values = activation(input_values)\n",
    "axs[1, 0].plot(input_values, output_values)\n",
    "axs[1, 0].set_title('Sigmoid')\n",
    "axs[1, 0].set_ylim([-1.1,1.1])\n",
    "\n",
    "#tanh activation\n",
    "activation = torch.nn.Tanh()\n",
    "output_values = activation(input_values)\n",
    "axs[1, 1].plot(input_values, output_values)\n",
    "axs[1, 1].set_title('Tanh')\n",
    "axs[1, 1].set_ylim([-1.1,1.1])\n",
    "\n",
    "#relu activation\n",
    "activation = torch.nn.ReLU()\n",
    "output_values = activation(input_values)\n",
    "axs[2, 0].plot(input_values, output_values)\n",
    "axs[2, 0].set_title('ReLU')\n",
    "axs[2, 0].set_ylim([-0.5,5.1])\n",
    "\n",
    "#leaky relu activation\n",
    "activation = torch.nn.LeakyReLU(negative_slope=0.05)\n",
    "output_values = activation(input_values)\n",
    "axs[2, 1].plot(input_values, output_values)\n",
    "axs[2, 1].set_title('Leaky ReLU')\n",
    "axs[2, 1].set_ylim([-0.5,5.1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 792x936 with 6 Axes>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fig_activation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For our fraud detection neural network, the `ReLU` activation will be used for the hidden layer and a `Sigmoid` activation for the output layer. The first is the primary choice for intermediate layers in deep learning. The latter is the primary choice for the output neurons in binary classification problems because it outputs values between 0 and 1 that can be interpreted as probabilities.\n",
    "\n",
    "To implement this, let us create a new class `SimpleFraudMLP` that will inherit from a torch module. Its layers (`fc1`, `relu`, `fc2`, `sigmoid`) are initialized in the `__init__` function and will be used successively in the forward pass.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleFraudMLP(torch.nn.Module):\n",
    "    \n",
    "        def __init__(self, input_size, hidden_size):\n",
    "            super(SimpleFraudMLP, self).__init__()\n",
    "            # parameters\n",
    "            self.input_size = input_size\n",
    "            self.hidden_size  = hidden_size\n",
    "            \n",
    "            #input to hidden\n",
    "            self.fc1 = torch.nn.Linear(self.input_size, self.hidden_size)\n",
    "            self.relu = torch.nn.ReLU()\n",
    "            #hidden to output\n",
    "            self.fc2 = torch.nn.Linear(self.hidden_size, 1)\n",
    "            self.sigmoid = torch.nn.Sigmoid()\n",
    "            \n",
    "        def forward(self, x):\n",
    "            \n",
    "            hidden = self.fc1(x)\n",
    "            relu = self.relu(hidden)\n",
    "            output = self.fc2(relu)\n",
    "            output = self.sigmoid(output)\n",
    "            \n",
    "            return output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once defined, instantiating the model with `1000` neurons in its hidden layer and sending it to the device can be done as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = SimpleFraudMLP(len(input_features), 1000).to(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The optimizer and the training loop\n",
    "\n",
    "Optimization is at the core of neural network training. The above neural network is designed to output a single value between 0 and 1. The goal is that this value gets as close to 1 (resp. 0) as possible for an input describing a fraudulent (resp. genuine) transaction.\n",
    "\n",
    "In practice, this goal is formulated with an optimization problem that aims at minimizing or maximizing some cost/loss function. The role of the loss function is precisely to measure the discrepancy between the predicted value and the expected value (0 or 1), also referred to as the ground truth. There are many loss functions (mean squared error, cross-entropy, KL-divergence, hinge loss, mean absolute error) available in PyTorch, and each serves a specific purpose. Here we only focus on binary cross-entropy because it is the most relevant loss function for binary classification problems like fraud detection. It is defined as follows:\n",
    "\n",
    "$BCE(y,p) = −(y*log(p)+(1−y)*log(1−p))$\n",
    "\n",
    "Where $y$ is the ground truth (in $\\{0,1\\}$) and $p$ the predicted output (in $]0,1[$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = torch.nn.BCELoss().to(DEVICE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: Pushing the criterion to the device is only required if this one stores/updates internal state variables or has parameters. It is unnecessary but not detrimental in the above case. We do it to show the most general implementation.\n",
    "\n",
    "Before even training the model, one can already measure its initial loss on the testing set. For this, the model has to be put in `eval` mode:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SimpleFraudMLP(\n",
       "  (fc1): Linear(in_features=15, out_features=1000, bias=True)\n",
       "  (relu): ReLU()\n",
       "  (fc2): Linear(in_features=1000, out_features=1, bias=True)\n",
       "  (sigmoid): Sigmoid()\n",
       ")"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, the process consists in iterating over the testing generator, making predictions, and evaluating the chosen `criterion` (here `torch.nn.BCELoss`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6754083250670742"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def evaluate_model(model,generator,criterion):\n",
    "    model.eval()\n",
    "    batch_losses = []\n",
    "    for x_batch, y_batch in generator:\n",
    "        # Forward pass\n",
    "        y_pred = model(x_batch)\n",
    "        # Compute Loss\n",
    "        loss = criterion(y_pred.squeeze(), y_batch)\n",
    "        batch_losses.append(loss.item())\n",
    "    mean_loss = np.mean(batch_losses)    \n",
    "    return mean_loss\n",
    "    \n",
    "evaluate_model(model,testing_generator,criterion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that the optimization problem is defined as follows: minimize the total/average binary cross-entropy of the model over all samples from the training dataset. Therefore, training the model consists in applying an optimization algorithm (backpropagation) to numerically solve the optimization problem. \n",
    "\n",
    "The optimization algorithm or `optimizer` can be the standard stochastic gradient descent with a constant learning rate (`torch.optim.SGD`) or with an adaptive learning rate (`torch.optim.Adagrad`, `torch.optim.Adam`, etc...). Several optimization hyperparameters (learning rate, momentum, batch size, ...) can be tuned. Note that choosing the right optimizer and hyperparameters will impact convergence speed and the quality of the reached optimum. Below is an illustration showing how fast different optimizers can reach the optimum (represented with a star) of a two dimensional optimization problem over the training process.\n",
    "\n",
    "![Optimizers convergence](https://ml-cheatsheet.readthedocs.io/en/latest/_images/optimizers.gif) \n",
    "\n",
    "Source: https://cs231n.github.io/neural-networks-3/\n",
    "\n",
    "\n",
    "Here, let us start with the arbitrary choice `SGD`, with a learning rate of `0.07`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.SGD(model.parameters(), lr = 0.07)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And let us implement the training loop for our neural network. First, the model has to be set in training mode. Then several iterations can be performed over the training generator (each iteration is called an epoch). During each iteration, a succession of training batches are provided by the generator and a forward pass is performed to get the model's predictions. Then the criterion is computed between predictions and ground truth, and finally, the backward pass is carried out to update the model with the optimizer.\n",
    "Let us start by setting the number of epochs to `150` arbitrarily. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: train loss: 0.035290839925911685\n",
      "test loss: 0.02218067791398807\n",
      "\n",
      "Epoch 1: train loss: 0.026134893728365197\n",
      "test loss: 0.021469182402057047\n",
      "\n",
      "Epoch 2: train loss: 0.0246561407407331\n",
      "test loss: 0.020574169931166553\n",
      "\n",
      "Epoch 3: train loss: 0.02423229484444929\n",
      "test loss: 0.02107386154216703\n",
      "\n",
      "Epoch 4: train loss: 0.023609313174003787\n",
      "test loss: 0.0210356019355784\n",
      "\n",
      "Epoch 5: train loss: 0.022873578722177552\n",
      "test loss: 0.019786655369601145\n",
      "\n",
      "Epoch 6: train loss: 0.022470950096939557\n",
      "test loss: 0.019926515792759236\n",
      "\n",
      "Epoch 7: train loss: 0.02219278062594085\n",
      "test loss: 0.028550955727806318\n",
      "\n",
      "Epoch 8: train loss: 0.022042355658335844\n",
      "test loss: 0.02049338448594368\n",
      "\n",
      "Epoch 9: train loss: 0.021793536896477114\n",
      "test loss: 0.019674824729140616\n",
      "\n",
      "Epoch 10: train loss: 0.021385407493539246\n",
      "test loss: 0.01945593247867908\n",
      "\n",
      "Epoch 11: train loss: 0.021190979423734237\n",
      "test loss: 0.019786519943567813\n",
      "\n",
      "Epoch 12: train loss: 0.020975370036498363\n",
      "test loss: 0.019642970249983027\n",
      "\n",
      "Epoch 13: train loss: 0.02076734111756866\n",
      "test loss: 0.02052513674605928\n",
      "\n",
      "Epoch 14: train loss: 0.020718587878236387\n",
      "test loss: 0.01951982097012225\n",
      "\n",
      "Epoch 15: train loss: 0.02052261461601278\n",
      "test loss: 0.02042003110112238\n",
      "\n",
      "Epoch 16: train loss: 0.020464933605720204\n",
      "test loss: 0.01951952900969588\n",
      "\n",
      "Epoch 17: train loss: 0.02031139105385157\n",
      "test loss: 0.019883068325074693\n",
      "\n",
      "Epoch 18: train loss: 0.02005033891893512\n",
      "test loss: 0.021136936702628534\n",
      "\n",
      "Epoch 19: train loss: 0.02018909637513194\n",
      "test loss: 0.019560931436896415\n",
      "\n",
      "Epoch 20: train loss: 0.019688749160297697\n",
      "test loss: 0.019475146327190752\n",
      "\n",
      "Epoch 21: train loss: 0.019545665294593013\n",
      "test loss: 0.01990481851439469\n",
      "\n",
      "Epoch 22: train loss: 0.01966426501701454\n",
      "test loss: 0.019774360520063372\n",
      "\n",
      "Epoch 23: train loss: 0.019467116548984597\n",
      "test loss: 0.01942398223827126\n",
      "\n",
      "Epoch 24: train loss: 0.019450417307287908\n",
      "test loss: 0.02036607543897992\n",
      "\n",
      "Epoch 25: train loss: 0.019348452326161104\n",
      "test loss: 0.01966385325294501\n",
      "\n",
      "Epoch 26: train loss: 0.019337252642960243\n",
      "test loss: 0.01941954461092479\n",
      "\n",
      "Epoch 27: train loss: 0.018811270653081438\n",
      "test loss: 0.02393198154940046\n",
      "\n",
      "Epoch 28: train loss: 0.01910782355698203\n",
      "test loss: 0.01893333827312034\n",
      "\n",
      "Epoch 29: train loss: 0.01889679451607306\n",
      "test loss: 0.0191712700046878\n",
      "\n",
      "Epoch 30: train loss: 0.018880406176723666\n",
      "test loss: 0.019288057992725535\n",
      "\n",
      "Epoch 31: train loss: 0.018777794314975487\n",
      "test loss: 0.019147953246904152\n",
      "\n",
      "Epoch 32: train loss: 0.018520837131095473\n",
      "test loss: 0.02091556165090575\n",
      "\n",
      "Epoch 33: train loss: 0.018716360642273444\n",
      "test loss: 0.0200009971591782\n",
      "\n",
      "Epoch 34: train loss: 0.018424111695009345\n",
      "test loss: 0.019739989193721698\n",
      "\n",
      "Epoch 35: train loss: 0.01847832238549308\n",
      "test loss: 0.018952790981592586\n",
      "\n",
      "Epoch 36: train loss: 0.01833176362245378\n",
      "test loss: 0.020047389050911392\n",
      "\n",
      "Epoch 37: train loss: 0.01840733835025275\n",
      "test loss: 0.019157873926489766\n",
      "\n",
      "Epoch 38: train loss: 0.018216611167059752\n",
      "test loss: 0.01925634399612826\n",
      "\n",
      "Epoch 39: train loss: 0.018247971196790058\n",
      "test loss: 0.019123039215892087\n",
      "\n",
      "Epoch 40: train loss: 0.01818877947228747\n",
      "test loss: 0.018829473494242827\n",
      "\n",
      "Epoch 41: train loss: 0.01801579236064007\n",
      "test loss: 0.02009236856039642\n",
      "\n",
      "Epoch 42: train loss: 0.01776886585207973\n",
      "test loss: 0.021591765647557278\n",
      "\n",
      "Epoch 43: train loss: 0.017698623019236925\n",
      "test loss: 0.019427421221762085\n",
      "\n",
      "Epoch 44: train loss: 0.017801190636184537\n",
      "test loss: 0.020934971890116567\n",
      "\n",
      "Epoch 45: train loss: 0.01757617438695864\n",
      "test loss: 0.020313221684501902\n",
      "\n",
      "Epoch 46: train loss: 0.017528431712814582\n",
      "test loss: 0.019237118583715917\n",
      "\n",
      "Epoch 47: train loss: 0.01771650113830862\n",
      "test loss: 0.019054257457372534\n",
      "\n",
      "Epoch 48: train loss: 0.017471631084365873\n",
      "test loss: 0.018768446161779733\n",
      "\n",
      "Epoch 49: train loss: 0.01762986665642107\n",
      "test loss: 0.01871213165666953\n",
      "\n",
      "Epoch 50: train loss: 0.017376677225189697\n",
      "test loss: 0.018944991090944246\n",
      "\n",
      "Epoch 51: train loss: 0.01731134802643582\n",
      "test loss: 0.019197071075790106\n",
      "\n",
      "Epoch 52: train loss: 0.017309057082782377\n",
      "test loss: 0.018737028158102676\n",
      "\n",
      "Epoch 53: train loss: 0.017282733941613764\n",
      "test loss: 0.019252458449021702\n",
      "\n",
      "Epoch 54: train loss: 0.017132009704110808\n",
      "test loss: 0.018666087535711397\n",
      "\n",
      "Epoch 55: train loss: 0.017102760767770647\n",
      "test loss: 0.019643470577414647\n",
      "\n",
      "Epoch 56: train loss: 0.017175561865192656\n",
      "test loss: 0.02059196266723934\n",
      "\n",
      "Epoch 57: train loss: 0.01697120425308196\n",
      "test loss: 0.019769266178551858\n",
      "\n",
      "Epoch 58: train loss: 0.017009864932326663\n",
      "test loss: 0.020981014218425704\n",
      "\n",
      "Epoch 59: train loss: 0.01673883281791712\n",
      "test loss: 0.019321667669907328\n",
      "\n",
      "Epoch 60: train loss: 0.01682613142252103\n",
      "test loss: 0.019117679840779805\n",
      "\n",
      "Epoch 61: train loss: 0.01683426277134231\n",
      "test loss: 0.019079260448347592\n",
      "\n",
      "Epoch 62: train loss: 0.01672560934473155\n",
      "test loss: 0.019345737459433483\n",
      "\n",
      "Epoch 63: train loss: 0.016557869988561853\n",
      "test loss: 0.01874406040829129\n",
      "\n",
      "Epoch 64: train loss: 0.01658480815486637\n",
      "test loss: 0.018706792446582257\n",
      "\n",
      "Epoch 65: train loss: 0.016553207060462174\n",
      "test loss: 0.01922788784218672\n",
      "\n",
      "Epoch 66: train loss: 0.01656300151070667\n",
      "test loss: 0.019106791167186204\n",
      "\n",
      "Epoch 67: train loss: 0.01634960973555121\n",
      "test loss: 0.01892106298902394\n",
      "\n",
      "Epoch 68: train loss: 0.01637238433257146\n",
      "test loss: 0.01970208241961054\n",
      "\n",
      "Epoch 69: train loss: 0.016304624745100346\n",
      "test loss: 0.020026253195723334\n",
      "\n",
      "Epoch 70: train loss: 0.016170715611227758\n",
      "test loss: 0.01916889895606555\n",
      "\n",
      "Epoch 71: train loss: 0.01625427650099445\n",
      "test loss: 0.02002084003181251\n",
      "\n",
      "Epoch 72: train loss: 0.016230222106588692\n",
      "test loss: 0.01973510921013191\n",
      "\n",
      "Epoch 73: train loss: 0.016057555596756222\n",
      "test loss: 0.019140344628865876\n",
      "\n",
      "Epoch 74: train loss: 0.016185298318253365\n",
      "test loss: 0.019592884734356532\n",
      "\n",
      "Epoch 75: train loss: 0.016135186496054263\n",
      "test loss: 0.01912933145930866\n",
      "\n",
      "Epoch 76: train loss: 0.015831470446746182\n",
      "test loss: 0.01980635219605146\n",
      "\n",
      "Epoch 77: train loss: 0.016163742120889904\n",
      "test loss: 0.018802218763737884\n",
      "\n",
      "Epoch 78: train loss: 0.015780061666036713\n",
      "test loss: 0.01946689938368842\n",
      "\n",
      "Epoch 79: train loss: 0.015624963660032394\n",
      "test loss: 0.019016587150318426\n",
      "\n",
      "Epoch 80: train loss: 0.015677704382997953\n",
      "test loss: 0.019123383783840122\n",
      "\n",
      "Epoch 81: train loss: 0.0156669273015934\n",
      "test loss: 0.019544906248615823\n",
      "\n",
      "Epoch 82: train loss: 0.015945699108347162\n",
      "test loss: 0.01896711020402914\n",
      "\n",
      "Epoch 83: train loss: 0.015803545366061742\n",
      "test loss: 0.01882257679583143\n",
      "\n",
      "Epoch 84: train loss: 0.01554203405311698\n",
      "test loss: 0.019160992536484494\n",
      "\n",
      "Epoch 85: train loss: 0.015593627287424059\n",
      "test loss: 0.02269861174688054\n",
      "\n",
      "Epoch 86: train loss: 0.015608393082631792\n",
      "test loss: 0.01906792499428118\n",
      "\n",
      "Epoch 87: train loss: 0.015573860835403621\n",
      "test loss: 0.018713722084268098\n",
      "\n",
      "Epoch 88: train loss: 0.015303678795089192\n",
      "test loss: 0.018859464580432892\n",
      "\n",
      "Epoch 89: train loss: 0.015624303529220682\n",
      "test loss: 0.019072787957337533\n",
      "\n",
      "Epoch 90: train loss: 0.015395271594389798\n",
      "test loss: 0.01925187274229275\n",
      "\n",
      "Epoch 91: train loss: 0.015199235446182222\n",
      "test loss: 0.019277529898914892\n",
      "\n",
      "Epoch 92: train loss: 0.015254125732097324\n",
      "test loss: 0.019276228871915446\n",
      "\n",
      "Epoch 93: train loss: 0.015056131997448768\n",
      "test loss: 0.01940738342764494\n",
      "\n",
      "Epoch 94: train loss: 0.015149828447423323\n",
      "test loss: 0.019223913595550125\n",
      "\n",
      "Epoch 95: train loss: 0.015336624930633124\n",
      "test loss: 0.018798039220534184\n",
      "\n",
      "Epoch 96: train loss: 0.015293191029795655\n",
      "test loss: 0.019010778412255576\n",
      "\n",
      "Epoch 97: train loss: 0.015008694369883785\n",
      "test loss: 0.019653212369427814\n",
      "\n",
      "Epoch 98: train loss: 0.015102840106516498\n",
      "test loss: 0.019357315392239054\n",
      "\n",
      "Epoch 99: train loss: 0.015250559438101515\n",
      "test loss: 0.018675536756820592\n",
      "\n",
      "Epoch 100: train loss: 0.014856535338572485\n",
      "test loss: 0.019066266391966104\n",
      "\n",
      "Epoch 101: train loss: 0.014888768182264608\n",
      "test loss: 0.019562842087552074\n",
      "\n",
      "Epoch 102: train loss: 0.015026554204328614\n",
      "test loss: 0.019209888092900036\n",
      "\n",
      "Epoch 103: train loss: 0.01470694792277262\n",
      "test loss: 0.019527851007887724\n",
      "\n",
      "Epoch 104: train loss: 0.014760883615509944\n",
      "test loss: 0.019603360463092235\n",
      "\n",
      "Epoch 105: train loss: 0.014778099678375702\n",
      "test loss: 0.01938396310747466\n",
      "\n",
      "Epoch 106: train loss: 0.014656903555221966\n",
      "test loss: 0.021055019364553493\n",
      "\n",
      "Epoch 107: train loss: 0.014742576584012136\n",
      "test loss: 0.019785542262680512\n",
      "\n",
      "Epoch 108: train loss: 0.014616272993597133\n",
      "test loss: 0.01918475812159322\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 109: train loss: 0.014744729096057526\n",
      "test loss: 0.019482410666562207\n",
      "\n",
      "Epoch 110: train loss: 0.01478639586868968\n",
      "test loss: 0.020755630938069685\n",
      "\n",
      "Epoch 111: train loss: 0.014646960172508015\n",
      "test loss: 0.019398048360927622\n",
      "\n",
      "Epoch 112: train loss: 0.01472245290016775\n",
      "test loss: 0.019159860661682446\n",
      "\n",
      "Epoch 113: train loss: 0.014562352736468128\n",
      "test loss: 0.019282711160597446\n",
      "\n",
      "Epoch 114: train loss: 0.014577984230900334\n",
      "test loss: 0.0193002821399542\n",
      "\n",
      "Epoch 115: train loss: 0.014344233295217433\n",
      "test loss: 0.020133854305154658\n",
      "\n",
      "Epoch 116: train loss: 0.014341190461110107\n",
      "test loss: 0.018970135359324077\n",
      "\n",
      "Epoch 117: train loss: 0.014129704338756278\n",
      "test loss: 0.01917728733261904\n",
      "\n",
      "Epoch 118: train loss: 0.01430605129179519\n",
      "test loss: 0.021149112656150264\n",
      "\n",
      "Epoch 119: train loss: 0.014255904436282473\n",
      "test loss: 0.018764410451399347\n",
      "\n",
      "Epoch 120: train loss: 0.014217122137308613\n",
      "test loss: 0.019560121930464764\n",
      "\n",
      "Epoch 121: train loss: 0.014424033683536841\n",
      "test loss: 0.019554240529785296\n",
      "\n",
      "Epoch 122: train loss: 0.013943179655692972\n",
      "test loss: 0.019388370742924505\n",
      "\n",
      "Epoch 123: train loss: 0.014217297587438277\n",
      "test loss: 0.019506819887417978\n",
      "\n",
      "Epoch 124: train loss: 0.014320325663093509\n",
      "test loss: 0.019013977995048798\n",
      "\n",
      "Epoch 125: train loss: 0.014072354838150605\n",
      "test loss: 0.019356480262935637\n",
      "\n",
      "Epoch 126: train loss: 0.014174860061636348\n",
      "test loss: 0.019924982428475582\n",
      "\n",
      "Epoch 127: train loss: 0.014051309499243181\n",
      "test loss: 0.01943692742414598\n",
      "\n",
      "Epoch 128: train loss: 0.013706501579084047\n",
      "test loss: 0.019356113880468657\n",
      "\n",
      "Epoch 129: train loss: 0.013928943851151433\n",
      "test loss: 0.023672922889693842\n",
      "\n",
      "Epoch 130: train loss: 0.013996419837717392\n",
      "test loss: 0.019937841926443746\n",
      "\n",
      "Epoch 131: train loss: 0.01354328335033992\n",
      "test loss: 0.018866847201061878\n",
      "\n",
      "Epoch 132: train loss: 0.013858712335960314\n",
      "test loss: 0.019526662786376717\n",
      "\n",
      "Epoch 133: train loss: 0.013627326418468455\n",
      "test loss: 0.019507627395780616\n",
      "\n",
      "Epoch 134: train loss: 0.01363016927038159\n",
      "test loss: 0.020167008346695766\n",
      "\n",
      "Epoch 135: train loss: 0.014017050037538007\n",
      "test loss: 0.019339477675381647\n",
      "\n",
      "Epoch 136: train loss: 0.013699612338492446\n",
      "test loss: 0.020203967244190785\n",
      "\n",
      "Epoch 137: train loss: 0.01374569109071234\n",
      "test loss: 0.020616953133759535\n",
      "\n",
      "Epoch 138: train loss: 0.013681518706248508\n",
      "test loss: 0.019543899178865818\n",
      "\n",
      "Epoch 139: train loss: 0.013486423249944396\n",
      "test loss: 0.020067024185707123\n",
      "\n",
      "Epoch 140: train loss: 0.013582284482316487\n",
      "test loss: 0.019309879371676077\n",
      "\n",
      "Epoch 141: train loss: 0.013726865840729302\n",
      "test loss: 0.019650126973995898\n",
      "\n",
      "Epoch 142: train loss: 0.013600045634118164\n",
      "test loss: 0.019795151278770167\n",
      "\n",
      "Epoch 143: train loss: 0.013150996427657836\n",
      "test loss: 0.02032829227653597\n",
      "\n",
      "Epoch 144: train loss: 0.01349108792122783\n",
      "test loss: 0.01965160865000445\n",
      "\n",
      "Epoch 145: train loss: 0.013093949061199017\n",
      "test loss: 0.020522381957106928\n",
      "\n",
      "Epoch 146: train loss: 0.01322205882253866\n",
      "test loss: 0.019739131280336053\n",
      "\n",
      "Epoch 147: train loss: 0.013211467955250392\n",
      "test loss: 0.019430110360044398\n",
      "\n",
      "Epoch 148: train loss: 0.013549773727725752\n",
      "test loss: 0.019252411015017387\n",
      "\n",
      "Epoch 149: train loss: 0.01308232067314798\n",
      "test loss: 0.019413354424067133\n",
      "\n"
     ]
    }
   ],
   "source": [
    "n_epochs = 150\n",
    "#Setting the model in training mode\n",
    "model.train()\n",
    "\n",
    "#Training loop\n",
    "start_time=time.time()\n",
    "epochs_train_losses = []\n",
    "epochs_test_losses = []\n",
    "for epoch in range(n_epochs):\n",
    "    model.train()\n",
    "    train_loss=[]\n",
    "    for x_batch, y_batch in training_generator:\n",
    "        # Removing previously computed gradients\n",
    "        optimizer.zero_grad()\n",
    "        # Performing the forward pass on the current batch\n",
    "        y_pred = model(x_batch)\n",
    "        # Computing the loss given the current predictions\n",
    "        loss = criterion(y_pred.squeeze(), y_batch)\n",
    "        # Computing the gradients over the backward pass\n",
    "        loss.backward()\n",
    "        # Performing an optimization step from the current gradients\n",
    "        optimizer.step()\n",
    "        # Storing the current step's loss for display purposes\n",
    "        train_loss.append(loss.item())\n",
    "    \n",
    "    #showing last training loss after each epoch\n",
    "    epochs_train_losses.append(np.mean(train_loss))\n",
    "    print('Epoch {}: train loss: {}'.format(epoch, np.mean(train_loss)))\n",
    "    \n",
    "    #evaluating the model on the test set after each epoch    \n",
    "    val_loss = evaluate_model(model,testing_generator,criterion)    \n",
    "    epochs_test_losses.append(val_loss)\n",
    "    print('test loss: {}'.format(val_loss))   \n",
    "    print(\"\")\n",
    "    \n",
    "training_execution_time=time.time()-start_time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After training the model, a good practice is to analyze the training logs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f9917c7a580>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ma_window = 10\n",
    "\n",
    "plt.plot(np.arange(len(epochs_train_losses)-ma_window + 1)+1, np.convolve(epochs_train_losses, np.ones(ma_window)/ma_window, mode='valid'))\n",
    "plt.plot(np.arange(len(epochs_test_losses)-ma_window + 1)+1, np.convolve(epochs_test_losses, np.ones(ma_window)/ma_window, mode='valid'))\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')\n",
    "plt.legend(['train','valid'])\n",
    "#plt.ylim([0.01,0.06])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "851.1251120567322\n"
     ]
    }
   ],
   "source": [
    "print(training_execution_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can note here how the training loss decreases epoch after epoch. This means that the optimization is going well: the chosen learning rate allows to update the model towards a better solution (lower loss) for the **training dataset**. However, neural networks are known to be very expressive models. In fact, the universal approximation theorem shows that, with enough neurons/layers, one can model any function with a neural network {cite}`cybenko1989approximation`. Therefore, it is expected for a complex neural network to be able to fit almost perfectly the training data. But the ultimate goal is to obtain a model that generalizes well on unseen data (like the validation set). Looking at the validation loss, one can see that it starts by decreasing (with oscillations) and it reaches an optimum around 0.019, and stops decreasing (or even starts increasing). This phenomenon is referred to as [overfitting](Model_Selection).\n",
    "\n",
    "Many aspects can be improved in the training. Although one cannot measure the performance on the final test set while training, one can rely on a validation set and try to stop training before overfitting (see [](Model_Selection)). One can also change the optimization algorithm and parameters to speed up training and reach a better optimum. This is investigated later, in the optimization paragraph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For now, let us consider this final fitted model and evaluate it the same way as the other models in previous chapters. For this, let us create a prediction DataFrame and call the `performance_assessment` function from the shared functions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predictions took 0.0022110939025878906 seconds.\n"
     ]
    }
   ],
   "source": [
    "start_time=time.time() \n",
    "predictions_test = model(x_test.to(DEVICE))\n",
    "prediction_execution_time = time.time()-start_time\n",
    "predictions_train = model(x_train.to(DEVICE))\n",
    "print(\"Predictions took\", prediction_execution_time,\"seconds.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AUC ROC</th>\n",
       "      <th>Average precision</th>\n",
       "      <th>Card Precision@100</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.864</td>\n",
       "      <td>0.653</td>\n",
       "      <td>0.286</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   AUC ROC  Average precision  Card Precision@100\n",
       "0    0.864              0.653               0.286"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predictions_df=test_df\n",
    "predictions_df['predictions']=predictions_test.detach().cpu().numpy()\n",
    "    \n",
    "performance_assessment(predictions_df, top_k_list=[100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This first shot feed-forward network already obtains a decent performance on the test set (refer to [Chapter 3.4](Baseline_FDS_Performances_Simulation) for comparison). But several elements can be modified to improve the AUC ROC, reduce the training time, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As stated above, for the first model, optimization was not carried out properly because the validation performance is not exploited during the training process. To avoid overfitting in practice, it is necessary to take it into account (See Chapter 5, [](Hold_Out_Validation))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta_valid = delta_test\n",
    "\n",
    "start_date_training_with_valid = start_date_training+datetime.timedelta(days=-(delta_delay+delta_valid))\n",
    "\n",
    "(train_df, valid_df)=get_train_test_set(transactions_df,start_date_training_with_valid,\n",
    "                                       delta_train=delta_train,delta_delay=delta_delay,delta_test=delta_test)\n",
    "\n",
    "# By default, scales input data\n",
    "(train_df, valid_df)=scaleData(train_df, valid_df, input_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us implement an early stopping strategy. The idea is to detect overfitting, i.e. when validation error starts increasing, and stop the training process. Sometimes, the validation error might increase at a given epoch, but then decrease again. For that reason, it is important to also consider a patience parameter, i.e. a number of iterations for which the training process waits in order to make sure that the error is definitely increasing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class EarlyStopping:\n",
    "    \n",
    "    def __init__(self, patience=2, verbose=False):\n",
    "        self.patience = patience\n",
    "        self.verbose = verbose\n",
    "        self.counter = 0\n",
    "        self.best_score = np.Inf\n",
    "    \n",
    "    def continue_training(self,current_score):\n",
    "        if self.best_score > current_score:\n",
    "            self.best_score = current_score\n",
    "            self.counter = 0\n",
    "            if self.verbose:\n",
    "                print(\"New best score:\", current_score)\n",
    "        else:\n",
    "            self.counter+=1\n",
    "            if self.verbose:\n",
    "                print(self.counter, \" iterations since best score.\")\n",
    "                \n",
    "        return self.counter <= self.patience        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed_everything(SEED)\n",
    "\n",
    "model = SimpleFraudMLP(len(input_features), 1000).to(DEVICE)\n",
    "\n",
    "def prepare_generators(train_df,valid_df,batch_size=64):\n",
    "    x_train = torch.FloatTensor(train_df[input_features].values)\n",
    "    x_valid = torch.FloatTensor(valid_df[input_features].values)\n",
    "    y_train = torch.FloatTensor(train_df[output_feature].values)\n",
    "    y_valid = torch.FloatTensor(valid_df[output_feature].values)\n",
    "    train_loader_params = {'batch_size': batch_size,\n",
    "              'shuffle': True,\n",
    "              'num_workers': 0}\n",
    "    valid_loader_params = {'batch_size': batch_size,\n",
    "              'num_workers': 0}\n",
    "    # Generators\n",
    "    \n",
    "    training_set = FraudDataset(x_train, y_train)\n",
    "    valid_set = FraudDataset(x_valid, y_valid)\n",
    "    \n",
    "    training_generator = torch.utils.data.DataLoader(training_set, **train_loader_params)\n",
    "    valid_generator = torch.utils.data.DataLoader(valid_set, **valid_loader_params)\n",
    "    \n",
    "    return training_generator,valid_generator\n",
    "\n",
    "training_generator,valid_generator = prepare_generators(train_df,valid_df,batch_size=64)\n",
    "\n",
    "criterion = torch.nn.BCELoss().to(DEVICE)\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr = 0.0005)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The training loop can now be adapted to integrate early stopping:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 0: train loss: 0.1913328490845047\n",
      "valid loss: 0.09375773465535679\n",
      "New best score: 0.09375773465535679\n",
      "\n",
      "Epoch 1: train loss: 0.09739777461463589\n",
      "valid loss: 0.06964004442421465\n",
      "New best score: 0.06964004442421465\n",
      "\n",
      "Epoch 2: train loss: 0.07702973348410874\n",
      "valid loss: 0.05692868165753252\n",
      "New best score: 0.05692868165753252\n",
      "\n",
      "Epoch 3: train loss: 0.06568225591940303\n",
      "valid loss: 0.05035814772171727\n",
      "New best score: 0.05035814772171727\n",
      "\n",
      "Epoch 4: train loss: 0.06026483534071345\n",
      "valid loss: 0.04624887502299306\n",
      "New best score: 0.04624887502299306\n",
      "\n",
      "Epoch 5: train loss: 0.056940919349244286\n",
      "valid loss: 0.04359364376449194\n",
      "New best score: 0.04359364376449194\n",
      "\n",
      "Epoch 6: train loss: 0.054429791377141476\n",
      "valid loss: 0.04157831529816969\n",
      "New best score: 0.04157831529816969\n",
      "\n",
      "Epoch 7: train loss: 0.052457363431094424\n",
      "valid loss: 0.04001519718599287\n",
      "New best score: 0.04001519718599287\n",
      "\n",
      "Epoch 8: train loss: 0.050785390330731414\n",
      "valid loss: 0.03874376885531867\n",
      "New best score: 0.03874376885531867\n",
      "\n",
      "Epoch 9: train loss: 0.04932902906317955\n",
      "valid loss: 0.03767143583403585\n",
      "New best score: 0.03767143583403585\n",
      "\n",
      "Epoch 10: train loss: 0.04800296786292874\n",
      "valid loss: 0.036723700269568164\n",
      "New best score: 0.036723700269568164\n",
      "\n",
      "Epoch 11: train loss: 0.0467992290715557\n",
      "valid loss: 0.03594793021129292\n",
      "New best score: 0.03594793021129292\n",
      "\n",
      "Epoch 12: train loss: 0.045708294409410904\n",
      "valid loss: 0.03513609678204594\n",
      "New best score: 0.03513609678204594\n",
      "\n",
      "Epoch 13: train loss: 0.044724561932031955\n",
      "valid loss: 0.034476374743170425\n",
      "New best score: 0.034476374743170425\n",
      "\n",
      "Epoch 14: train loss: 0.04376962262225367\n",
      "valid loss: 0.03383087654867785\n",
      "New best score: 0.03383087654867785\n",
      "\n",
      "Epoch 15: train loss: 0.04289912999684194\n",
      "valid loss: 0.03328745677008655\n",
      "New best score: 0.03328745677008655\n",
      "\n",
      "Epoch 16: train loss: 0.04211900097871801\n",
      "valid loss: 0.03279653103523404\n",
      "New best score: 0.03279653103523404\n",
      "\n",
      "Epoch 17: train loss: 0.04133166673274472\n",
      "valid loss: 0.03225325013668648\n",
      "New best score: 0.03225325013668648\n",
      "\n",
      "Epoch 18: train loss: 0.0406280806302369\n",
      "valid loss: 0.03180343335687789\n",
      "New best score: 0.03180343335687789\n",
      "\n",
      "Epoch 19: train loss: 0.039973342111405435\n",
      "valid loss: 0.03134397429113831\n",
      "New best score: 0.03134397429113831\n",
      "\n",
      "Epoch 20: train loss: 0.0393654040050253\n",
      "valid loss: 0.03092465683960361\n",
      "New best score: 0.03092465683960361\n",
      "\n",
      "Epoch 21: train loss: 0.03881909422234527\n",
      "valid loss: 0.03055180991577402\n",
      "New best score: 0.03055180991577402\n",
      "\n",
      "Epoch 22: train loss: 0.03827888194478721\n",
      "valid loss: 0.030233140898960047\n",
      "New best score: 0.030233140898960047\n",
      "\n",
      "Epoch 23: train loss: 0.03780341152338593\n",
      "valid loss: 0.029879456755954548\n",
      "New best score: 0.029879456755954548\n",
      "\n",
      "Epoch 24: train loss: 0.0373732605668579\n",
      "valid loss: 0.029598503501810987\n",
      "New best score: 0.029598503501810987\n",
      "\n",
      "Epoch 25: train loss: 0.03695048963789958\n",
      "valid loss: 0.02927447263802824\n",
      "New best score: 0.02927447263802824\n",
      "\n",
      "Epoch 26: train loss: 0.036615738789435213\n",
      "valid loss: 0.02896905600607314\n",
      "New best score: 0.02896905600607314\n",
      "\n",
      "Epoch 27: train loss: 0.036207901082405854\n",
      "valid loss: 0.02868095043018623\n",
      "New best score: 0.02868095043018623\n",
      "\n",
      "Epoch 28: train loss: 0.035899569037820905\n",
      "valid loss: 0.02845362258688267\n",
      "New best score: 0.02845362258688267\n",
      "\n",
      "Epoch 29: train loss: 0.035585474596406916\n",
      "valid loss: 0.0282213641676665\n",
      "New best score: 0.0282213641676665\n",
      "\n",
      "Epoch 30: train loss: 0.03530147399692787\n",
      "valid loss: 0.028004939610881557\n",
      "New best score: 0.028004939610881557\n",
      "\n",
      "Epoch 31: train loss: 0.03506627075336731\n",
      "valid loss: 0.027803662563343354\n",
      "New best score: 0.027803662563343354\n",
      "\n",
      "Epoch 32: train loss: 0.034790630911318426\n",
      "valid loss: 0.02759764206499024\n",
      "New best score: 0.02759764206499024\n",
      "\n",
      "Epoch 33: train loss: 0.03455478501155346\n",
      "valid loss: 0.027440349387178004\n",
      "New best score: 0.027440349387178004\n",
      "\n",
      "Epoch 34: train loss: 0.03433797730980566\n",
      "valid loss: 0.027257424232656837\n",
      "New best score: 0.027257424232656837\n",
      "\n",
      "Epoch 35: train loss: 0.03413862231931868\n",
      "valid loss: 0.027060411588029295\n",
      "New best score: 0.027060411588029295\n",
      "\n",
      "Epoch 36: train loss: 0.03393446611165715\n",
      "valid loss: 0.026920503835433006\n",
      "New best score: 0.026920503835433006\n",
      "\n",
      "Epoch 37: train loss: 0.03374493613983389\n",
      "valid loss: 0.026792875826969497\n",
      "New best score: 0.026792875826969497\n",
      "\n",
      "Epoch 38: train loss: 0.033567726451380044\n",
      "valid loss: 0.026641243333353208\n",
      "New best score: 0.026641243333353208\n",
      "\n",
      "Epoch 39: train loss: 0.03341253091052288\n",
      "valid loss: 0.026517281875706435\n",
      "New best score: 0.026517281875706435\n",
      "\n",
      "Epoch 40: train loss: 0.03323691976292283\n",
      "valid loss: 0.026393191043613224\n",
      "New best score: 0.026393191043613224\n",
      "\n",
      "Epoch 41: train loss: 0.03309235302152657\n",
      "valid loss: 0.026288463208885466\n",
      "New best score: 0.026288463208885466\n",
      "\n",
      "Epoch 42: train loss: 0.03293785912716622\n",
      "valid loss: 0.026179640229709977\n",
      "New best score: 0.026179640229709977\n",
      "\n",
      "Epoch 43: train loss: 0.03279621294436061\n",
      "valid loss: 0.02603624322212459\n",
      "New best score: 0.02603624322212459\n",
      "\n",
      "Epoch 44: train loss: 0.03266078568407357\n",
      "valid loss: 0.025929251656730157\n",
      "New best score: 0.025929251656730157\n",
      "\n",
      "Epoch 45: train loss: 0.0325486152223623\n",
      "valid loss: 0.025851620896592167\n",
      "New best score: 0.025851620896592167\n",
      "\n",
      "Epoch 46: train loss: 0.03240748641017048\n",
      "valid loss: 0.025761372189907754\n",
      "New best score: 0.025761372189907754\n",
      "\n",
      "Epoch 47: train loss: 0.03228628662429095\n",
      "valid loss: 0.02565560621245067\n",
      "New best score: 0.02565560621245067\n",
      "\n",
      "Epoch 48: train loss: 0.032172352504733076\n",
      "valid loss: 0.02557775412731972\n",
      "New best score: 0.02557775412731972\n",
      "\n",
      "Epoch 49: train loss: 0.03205738163439212\n",
      "valid loss: 0.02546982061209493\n",
      "New best score: 0.02546982061209493\n",
      "\n",
      "Epoch 50: train loss: 0.03195213218420801\n",
      "valid loss: 0.025422557447451713\n",
      "New best score: 0.025422557447451713\n",
      "\n",
      "Epoch 51: train loss: 0.03188026639638223\n",
      "valid loss: 0.025320453349948743\n",
      "New best score: 0.025320453349948743\n",
      "\n",
      "Epoch 52: train loss: 0.03174724143548703\n",
      "valid loss: 0.025241477420563742\n",
      "New best score: 0.025241477420563742\n",
      "\n",
      "Epoch 53: train loss: 0.03165151671476192\n",
      "valid loss: 0.025179216701313446\n",
      "New best score: 0.025179216701313446\n",
      "\n",
      "Epoch 54: train loss: 0.03155849563593604\n",
      "valid loss: 0.025118731856956834\n",
      "New best score: 0.025118731856956834\n",
      "\n",
      "Epoch 55: train loss: 0.03148277452568137\n",
      "valid loss: 0.025032085685130677\n",
      "New best score: 0.025032085685130677\n",
      "\n",
      "Epoch 56: train loss: 0.03140361373264691\n",
      "valid loss: 0.02498556302880736\n",
      "New best score: 0.02498556302880736\n",
      "\n",
      "Epoch 57: train loss: 0.03129253131212813\n",
      "valid loss: 0.024921924847844844\n",
      "New best score: 0.024921924847844844\n",
      "\n",
      "Epoch 58: train loss: 0.03121994449432056\n",
      "valid loss: 0.024863514974407974\n",
      "New best score: 0.024863514974407974\n",
      "\n",
      "Epoch 59: train loss: 0.031125062090090083\n",
      "valid loss: 0.024810835887560917\n",
      "New best score: 0.024810835887560917\n",
      "\n",
      "Epoch 60: train loss: 0.031047032346475305\n",
      "valid loss: 0.02475847759859158\n",
      "New best score: 0.02475847759859158\n",
      "\n",
      "Epoch 61: train loss: 0.030969077953846187\n",
      "valid loss: 0.024699673177216386\n",
      "New best score: 0.024699673177216386\n",
      "\n",
      "Epoch 62: train loss: 0.03090025394390129\n",
      "valid loss: 0.024641404968121502\n",
      "New best score: 0.024641404968121502\n",
      "\n",
      "Epoch 63: train loss: 0.030862686669909847\n",
      "valid loss: 0.024588247217604373\n",
      "New best score: 0.024588247217604373\n",
      "\n",
      "Epoch 64: train loss: 0.030749225534007208\n",
      "valid loss: 0.02454875350568464\n",
      "New best score: 0.02454875350568464\n",
      "\n",
      "Epoch 65: train loss: 0.030681132341612193\n",
      "valid loss: 0.02449575268454809\n",
      "New best score: 0.02449575268454809\n",
      "\n",
      "Epoch 66: train loss: 0.030624778894084305\n",
      "valid loss: 0.02444306879655504\n",
      "New best score: 0.02444306879655504\n",
      "\n",
      "Epoch 67: train loss: 0.030545241735879167\n",
      "valid loss: 0.02441780281487262\n",
      "New best score: 0.02441780281487262\n",
      "\n",
      "Epoch 68: train loss: 0.030487007927149534\n",
      "valid loss: 0.024349838984835018\n",
      "New best score: 0.024349838984835018\n",
      "\n",
      "Epoch 69: train loss: 0.030432759078324597\n",
      "valid loss: 0.0243099326176233\n",
      "New best score: 0.0243099326176233\n",
      "\n",
      "Epoch 70: train loss: 0.03041622593458457\n",
      "valid loss: 0.024272297082540115\n",
      "New best score: 0.024272297082540115\n",
      "\n",
      "Epoch 71: train loss: 0.030300165977093958\n",
      "valid loss: 0.024237286337127125\n",
      "New best score: 0.024237286337127125\n",
      "\n",
      "Epoch 72: train loss: 0.030241341069233863\n",
      "valid loss: 0.02417136665301326\n",
      "New best score: 0.02417136665301326\n",
      "\n",
      "Epoch 73: train loss: 0.03018520880436229\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "valid loss: 0.024120652137700815\n",
      "New best score: 0.024120652137700815\n",
      "\n",
      "Epoch 74: train loss: 0.03013364729372674\n",
      "valid loss: 0.024093669633345444\n",
      "New best score: 0.024093669633345444\n",
      "\n",
      "Epoch 75: train loss: 0.030071343618924114\n",
      "valid loss: 0.024088013470121992\n",
      "New best score: 0.024088013470121992\n",
      "\n",
      "Epoch 76: train loss: 0.03001892710608532\n",
      "valid loss: 0.024011776422002848\n",
      "New best score: 0.024011776422002848\n",
      "\n",
      "Epoch 77: train loss: 0.029969145755335175\n",
      "valid loss: 0.023975220763333183\n",
      "New best score: 0.023975220763333183\n",
      "\n",
      "Epoch 78: train loss: 0.02991881920848341\n",
      "valid loss: 0.02395541004638081\n",
      "New best score: 0.02395541004638081\n",
      "\n",
      "Epoch 79: train loss: 0.02986845553449282\n",
      "valid loss: 0.02393013280867268\n",
      "New best score: 0.02393013280867268\n",
      "\n",
      "Epoch 80: train loss: 0.029822142165907468\n",
      "valid loss: 0.023900585737629015\n",
      "New best score: 0.023900585737629015\n",
      "\n",
      "Epoch 81: train loss: 0.029775497005419024\n",
      "valid loss: 0.023856908664402494\n",
      "New best score: 0.023856908664402494\n",
      "\n",
      "Epoch 82: train loss: 0.029724118022878526\n",
      "valid loss: 0.023814442141307263\n",
      "New best score: 0.023814442141307263\n",
      "\n",
      "Epoch 83: train loss: 0.029677337395021937\n",
      "valid loss: 0.023799496913542512\n",
      "New best score: 0.023799496913542512\n",
      "\n",
      "Epoch 84: train loss: 0.029632960171946263\n",
      "valid loss: 0.023763575294701373\n",
      "New best score: 0.023763575294701373\n",
      "\n",
      "Epoch 85: train loss: 0.029605798028190453\n",
      "valid loss: 0.023751684766049025\n",
      "New best score: 0.023751684766049025\n",
      "\n",
      "Epoch 86: train loss: 0.02954536723106544\n",
      "valid loss: 0.023722586527853553\n",
      "New best score: 0.023722586527853553\n",
      "\n",
      "Epoch 87: train loss: 0.02950361069228614\n",
      "valid loss: 0.02369303354774627\n",
      "New best score: 0.02369303354774627\n",
      "\n",
      "Epoch 88: train loss: 0.029461566101934185\n",
      "valid loss: 0.023656040358565788\n",
      "New best score: 0.023656040358565788\n",
      "\n",
      "Epoch 89: train loss: 0.02946843091691408\n",
      "valid loss: 0.023631087498983645\n",
      "New best score: 0.023631087498983645\n",
      "\n",
      "Epoch 90: train loss: 0.029390632712244846\n",
      "valid loss: 0.023596429532454884\n",
      "New best score: 0.023596429532454884\n",
      "\n",
      "Epoch 91: train loss: 0.02936394038088406\n",
      "valid loss: 0.02358429558254534\n",
      "New best score: 0.02358429558254534\n",
      "\n",
      "Epoch 92: train loss: 0.0292979597964771\n",
      "valid loss: 0.023570768526740005\n",
      "New best score: 0.023570768526740005\n",
      "\n",
      "Epoch 93: train loss: 0.02927289446072393\n",
      "valid loss: 0.02350624052634656\n",
      "New best score: 0.02350624052634656\n",
      "\n",
      "Epoch 94: train loss: 0.029223493826807074\n",
      "valid loss: 0.023486437192542956\n",
      "New best score: 0.023486437192542956\n",
      "\n",
      "Epoch 95: train loss: 0.02918589157346159\n",
      "valid loss: 0.023464245512277458\n",
      "New best score: 0.023464245512277458\n",
      "\n",
      "Epoch 96: train loss: 0.029144589333789668\n",
      "valid loss: 0.023416468044081346\n",
      "New best score: 0.023416468044081346\n",
      "\n",
      "Epoch 97: train loss: 0.02912758567671418\n",
      "valid loss: 0.023399247189912476\n",
      "New best score: 0.023399247189912476\n",
      "\n",
      "Epoch 98: train loss: 0.02907554728173104\n",
      "valid loss: 0.023369539759880126\n",
      "New best score: 0.023369539759880126\n",
      "\n",
      "Epoch 99: train loss: 0.0290912055496365\n",
      "valid loss: 0.0233648722342475\n",
      "New best score: 0.0233648722342475\n",
      "\n",
      "Epoch 100: train loss: 0.029008036460878815\n",
      "valid loss: 0.023355054730915877\n",
      "New best score: 0.023355054730915877\n",
      "\n",
      "Epoch 101: train loss: 0.028976725650564847\n",
      "valid loss: 0.02335138803861954\n",
      "New best score: 0.02335138803861954\n",
      "\n",
      "Epoch 102: train loss: 0.028942817495779684\n",
      "valid loss: 0.023320194269667884\n",
      "New best score: 0.023320194269667884\n",
      "\n",
      "Epoch 103: train loss: 0.028908641032169415\n",
      "valid loss: 0.02326713968322821\n",
      "New best score: 0.02326713968322821\n",
      "\n",
      "Epoch 104: train loss: 0.02887047877260101\n",
      "valid loss: 0.023294708241143675\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 105: train loss: 0.028846722699872738\n",
      "valid loss: 0.023242005218797532\n",
      "New best score: 0.023242005218797532\n",
      "\n",
      "Epoch 106: train loss: 0.028813878833547763\n",
      "valid loss: 0.023228671088244744\n",
      "New best score: 0.023228671088244744\n",
      "\n",
      "Epoch 107: train loss: 0.0287828464368198\n",
      "valid loss: 0.023191343482247873\n",
      "New best score: 0.023191343482247873\n",
      "\n",
      "Epoch 108: train loss: 0.028756805844284437\n",
      "valid loss: 0.02318918440959167\n",
      "New best score: 0.02318918440959167\n",
      "\n",
      "Epoch 109: train loss: 0.028723424002724072\n",
      "valid loss: 0.023160055014075802\n",
      "New best score: 0.023160055014075802\n",
      "\n",
      "Epoch 110: train loss: 0.02869303663547042\n",
      "valid loss: 0.023144750117675448\n",
      "New best score: 0.023144750117675448\n",
      "\n",
      "Epoch 111: train loss: 0.028664296415472405\n",
      "valid loss: 0.023132199461475177\n",
      "New best score: 0.023132199461475177\n",
      "\n",
      "Epoch 112: train loss: 0.02863481912421807\n",
      "valid loss: 0.02309743918585362\n",
      "New best score: 0.02309743918585362\n",
      "\n",
      "Epoch 113: train loss: 0.02860824634382469\n",
      "valid loss: 0.023083067486123716\n",
      "New best score: 0.023083067486123716\n",
      "\n",
      "Epoch 114: train loss: 0.028580453087679016\n",
      "valid loss: 0.023065064372393033\n",
      "New best score: 0.023065064372393033\n",
      "\n",
      "Epoch 115: train loss: 0.028583913627721683\n",
      "valid loss: 0.023059428991403817\n",
      "New best score: 0.023059428991403817\n",
      "\n",
      "Epoch 116: train loss: 0.028539594658160757\n",
      "valid loss: 0.023021483237605767\n",
      "New best score: 0.023021483237605767\n",
      "\n",
      "Epoch 117: train loss: 0.028498090858825875\n",
      "valid loss: 0.0230103495645291\n",
      "New best score: 0.0230103495645291\n",
      "\n",
      "Epoch 118: train loss: 0.02847093119651941\n",
      "valid loss: 0.022989906041623383\n",
      "New best score: 0.022989906041623383\n",
      "\n",
      "Epoch 119: train loss: 0.028445423570689504\n",
      "valid loss: 0.02298577562040685\n",
      "New best score: 0.02298577562040685\n",
      "\n",
      "Epoch 120: train loss: 0.02843944391526859\n",
      "valid loss: 0.02297029253553416\n",
      "New best score: 0.02297029253553416\n",
      "\n",
      "Epoch 121: train loss: 0.02839335314034668\n",
      "valid loss: 0.022956622955821904\n",
      "New best score: 0.022956622955821904\n",
      "\n",
      "Epoch 122: train loss: 0.02836992497084908\n",
      "valid loss: 0.02292723284062263\n",
      "New best score: 0.02292723284062263\n",
      "\n",
      "Epoch 123: train loss: 0.028345879081175456\n",
      "valid loss: 0.02292975828311116\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 124: train loss: 0.028317808104148332\n",
      "valid loss: 0.022887073724932684\n",
      "New best score: 0.022887073724932684\n",
      "\n",
      "Epoch 125: train loss: 0.028294943689313463\n",
      "valid loss: 0.02287090510369121\n",
      "New best score: 0.02287090510369121\n",
      "\n",
      "Epoch 126: train loss: 0.028270350065105462\n",
      "valid loss: 0.02287252673808017\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 127: train loss: 0.028275767688721375\n",
      "valid loss: 0.022849381183492924\n",
      "New best score: 0.022849381183492924\n",
      "\n",
      "Epoch 128: train loss: 0.028224381290101953\n",
      "valid loss: 0.022848820957085472\n",
      "New best score: 0.022848820957085472\n",
      "\n",
      "Epoch 129: train loss: 0.028200230417402737\n",
      "valid loss: 0.022820619613064523\n",
      "New best score: 0.022820619613064523\n",
      "\n",
      "Epoch 130: train loss: 0.028176542286481532\n",
      "valid loss: 0.02281207342764434\n",
      "New best score: 0.02281207342764434\n",
      "\n",
      "Epoch 131: train loss: 0.02815248865641326\n",
      "valid loss: 0.02280835929693135\n",
      "New best score: 0.02280835929693135\n",
      "\n",
      "Epoch 132: train loss: 0.028131953311948742\n",
      "valid loss: 0.022787688048607337\n",
      "New best score: 0.022787688048607337\n",
      "\n",
      "Epoch 133: train loss: 0.02810920693534987\n",
      "valid loss: 0.022765636864713713\n",
      "New best score: 0.022765636864713713\n",
      "\n",
      "Epoch 134: train loss: 0.028111470830279543\n",
      "valid loss: 0.022741809560627234\n",
      "New best score: 0.022741809560627234\n",
      "\n",
      "Epoch 135: train loss: 0.028099982538946102\n",
      "valid loss: 0.022723406667266386\n",
      "New best score: 0.022723406667266386\n",
      "\n",
      "Epoch 136: train loss: 0.028045140870136296\n",
      "valid loss: 0.022711630711901954\n",
      "New best score: 0.022711630711901954\n",
      "\n",
      "Epoch 137: train loss: 0.028020675978124725\n",
      "valid loss: 0.02270077230469858\n",
      "New best score: 0.02270077230469858\n",
      "\n",
      "Epoch 138: train loss: 0.028001034442232085\n",
      "valid loss: 0.022680820606374105\n",
      "New best score: 0.022680820606374105\n",
      "\n",
      "Epoch 139: train loss: 0.02798138180169781\n",
      "valid loss: 0.022678537435239295\n",
      "New best score: 0.022678537435239295\n",
      "\n",
      "Epoch 140: train loss: 0.027956969244939848\n",
      "valid loss: 0.022645182927938108\n",
      "New best score: 0.022645182927938108\n",
      "\n",
      "Epoch 141: train loss: 0.02793828301206516\n",
      "valid loss: 0.02263188965267456\n",
      "New best score: 0.02263188965267456\n",
      "\n",
      "Epoch 142: train loss: 0.027918862506798887\n",
      "valid loss: 0.022637629473602268\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 143: train loss: 0.02789739242409415\n",
      "valid loss: 0.022616112196838352\n",
      "New best score: 0.022616112196838352\n",
      "\n",
      "Epoch 144: train loss: 0.02788659036435529\n",
      "valid loss: 0.022604331468827413\n",
      "New best score: 0.022604331468827413\n",
      "\n",
      "Epoch 145: train loss: 0.027857656635381423\n",
      "valid loss: 0.02258195599510533\n",
      "New best score: 0.02258195599510533\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 146: train loss: 0.027839381755712527\n",
      "valid loss: 0.022589396648974122\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 147: train loss: 0.02781995714808606\n",
      "valid loss: 0.022585400501062555\n",
      "2  iterations since best score.\n",
      "\n",
      "Epoch 148: train loss: 0.0278003837200537\n",
      "valid loss: 0.022568948230772316\n",
      "New best score: 0.022568948230772316\n",
      "\n",
      "Epoch 149: train loss: 0.027782129139833536\n",
      "valid loss: 0.02255174289432054\n",
      "New best score: 0.02255174289432054\n",
      "\n",
      "Epoch 150: train loss: 0.02776255571714337\n",
      "valid loss: 0.02253183182914197\n",
      "New best score: 0.02253183182914197\n",
      "\n",
      "Epoch 151: train loss: 0.027743494876679993\n",
      "valid loss: 0.022533289264745075\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 152: train loss: 0.02775508448228696\n",
      "valid loss: 0.02251671864193116\n",
      "New best score: 0.02251671864193116\n",
      "\n",
      "Epoch 153: train loss: 0.027706991043075363\n",
      "valid loss: 0.02250744028123798\n",
      "New best score: 0.02250744028123798\n",
      "\n",
      "Epoch 154: train loss: 0.02771934628865929\n",
      "valid loss: 0.022485052686581602\n",
      "New best score: 0.022485052686581602\n",
      "\n",
      "Epoch 155: train loss: 0.027669533327476514\n",
      "valid loss: 0.02247313265154352\n",
      "New best score: 0.02247313265154352\n",
      "\n",
      "Epoch 156: train loss: 0.027651057377623228\n",
      "valid loss: 0.022459305293827517\n",
      "New best score: 0.022459305293827517\n",
      "\n",
      "Epoch 157: train loss: 0.02763525061585351\n",
      "valid loss: 0.02245297230032013\n",
      "New best score: 0.02245297230032013\n",
      "\n",
      "Epoch 158: train loss: 0.027679454755388827\n",
      "valid loss: 0.02244625367056273\n",
      "New best score: 0.02244625367056273\n",
      "\n",
      "Epoch 159: train loss: 0.027604569671639947\n",
      "valid loss: 0.022432177785600794\n",
      "New best score: 0.022432177785600794\n",
      "\n",
      "Epoch 160: train loss: 0.027581669508397622\n",
      "valid loss: 0.022430453333199596\n",
      "New best score: 0.022430453333199596\n",
      "\n",
      "Epoch 161: train loss: 0.027564720215941876\n",
      "valid loss: 0.02241775643925279\n",
      "New best score: 0.02241775643925279\n",
      "\n",
      "Epoch 162: train loss: 0.027579767085268138\n",
      "valid loss: 0.02239429562255903\n",
      "New best score: 0.02239429562255903\n",
      "\n",
      "Epoch 163: train loss: 0.02753278665911463\n",
      "valid loss: 0.02241013890763368\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 164: train loss: 0.027514616644275278\n",
      "valid loss: 0.02239029550762043\n",
      "New best score: 0.02239029550762043\n",
      "\n",
      "Epoch 165: train loss: 0.0274962666923052\n",
      "valid loss: 0.022379505229716906\n",
      "New best score: 0.022379505229716906\n",
      "\n",
      "Epoch 166: train loss: 0.027480541330666047\n",
      "valid loss: 0.022358953526823735\n",
      "New best score: 0.022358953526823735\n",
      "\n",
      "Epoch 167: train loss: 0.027462416702220806\n",
      "valid loss: 0.02235966007164145\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 168: train loss: 0.027444096298596284\n",
      "valid loss: 0.022322355202129468\n",
      "New best score: 0.022322355202129468\n",
      "\n",
      "Epoch 169: train loss: 0.027431257501383442\n",
      "valid loss: 0.022331677362974225\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 170: train loss: 0.027412834448827143\n",
      "valid loss: 0.02231330466558495\n",
      "New best score: 0.02231330466558495\n",
      "\n",
      "Epoch 171: train loss: 0.027397032502823177\n",
      "valid loss: 0.022294207703820915\n",
      "New best score: 0.022294207703820915\n",
      "\n",
      "Epoch 172: train loss: 0.0274509967615949\n",
      "valid loss: 0.022283703407089486\n",
      "New best score: 0.022283703407089486\n",
      "\n",
      "Epoch 173: train loss: 0.027366497663845153\n",
      "valid loss: 0.022291729623920033\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 174: train loss: 0.027348620703988788\n",
      "valid loss: 0.02226596312760248\n",
      "New best score: 0.02226596312760248\n",
      "\n",
      "Epoch 175: train loss: 0.027336257964196344\n",
      "valid loss: 0.022264154464810518\n",
      "New best score: 0.022264154464810518\n",
      "\n",
      "Epoch 176: train loss: 0.027319475778478267\n",
      "valid loss: 0.02225901745997695\n",
      "New best score: 0.02225901745997695\n",
      "\n",
      "Epoch 177: train loss: 0.02730279668732003\n",
      "valid loss: 0.02226781084309103\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 178: train loss: 0.027288165774167896\n",
      "valid loss: 0.022257838008894783\n",
      "New best score: 0.022257838008894783\n",
      "\n",
      "Epoch 179: train loss: 0.027274338977035656\n",
      "valid loss: 0.022235579778251996\n",
      "New best score: 0.022235579778251996\n",
      "\n",
      "Epoch 180: train loss: 0.027257639051096277\n",
      "valid loss: 0.0222349306349668\n",
      "New best score: 0.0222349306349668\n",
      "\n",
      "Epoch 181: train loss: 0.0272431151781598\n",
      "valid loss: 0.0222269894069193\n",
      "New best score: 0.0222269894069193\n",
      "\n",
      "Epoch 182: train loss: 0.027227670632536036\n",
      "valid loss: 0.02222529236466466\n",
      "New best score: 0.02222529236466466\n",
      "\n",
      "Epoch 183: train loss: 0.02721316859092257\n",
      "valid loss: 0.022205822349174835\n",
      "New best score: 0.022205822349174835\n",
      "\n",
      "Epoch 184: train loss: 0.027198939605786985\n",
      "valid loss: 0.02218940971887421\n",
      "New best score: 0.02218940971887421\n",
      "\n",
      "Epoch 185: train loss: 0.027183696735351138\n",
      "valid loss: 0.02218479550713317\n",
      "New best score: 0.02218479550713317\n",
      "\n",
      "Epoch 186: train loss: 0.027172062066107647\n",
      "valid loss: 0.022171826308715295\n",
      "New best score: 0.022171826308715295\n",
      "\n",
      "Epoch 187: train loss: 0.02715572778266422\n",
      "valid loss: 0.022156602788024424\n",
      "New best score: 0.022156602788024424\n",
      "\n",
      "Epoch 188: train loss: 0.027142122838188527\n",
      "valid loss: 0.022152840110977165\n",
      "New best score: 0.022152840110977165\n",
      "\n",
      "Epoch 189: train loss: 0.027156833799673426\n",
      "valid loss: 0.022135975122543387\n",
      "New best score: 0.022135975122543387\n",
      "\n",
      "Epoch 190: train loss: 0.027116888003952688\n",
      "valid loss: 0.022136385554111883\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 191: train loss: 0.027097924722645283\n",
      "valid loss: 0.022135188155222297\n",
      "New best score: 0.022135188155222297\n",
      "\n",
      "Epoch 192: train loss: 0.027096894630017274\n",
      "valid loss: 0.022115503400920437\n",
      "New best score: 0.022115503400920437\n",
      "\n",
      "Epoch 193: train loss: 0.02707694551438257\n",
      "valid loss: 0.02211413178821934\n",
      "New best score: 0.02211413178821934\n",
      "\n",
      "Epoch 194: train loss: 0.02705197550830953\n",
      "valid loss: 0.02207818727029355\n",
      "New best score: 0.02207818727029355\n",
      "\n",
      "Epoch 195: train loss: 0.027042816159578955\n",
      "valid loss: 0.02208785341767584\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 196: train loss: 0.0270271035829242\n",
      "valid loss: 0.022097130685973444\n",
      "2  iterations since best score.\n",
      "\n",
      "Epoch 197: train loss: 0.027014468928325357\n",
      "valid loss: 0.02206936632054018\n",
      "New best score: 0.02206936632054018\n",
      "\n",
      "Epoch 198: train loss: 0.02700017227338944\n",
      "valid loss: 0.02208895876067258\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 199: train loss: 0.026988290910284974\n",
      "valid loss: 0.022064897909129414\n",
      "New best score: 0.022064897909129414\n",
      "\n",
      "Epoch 200: train loss: 0.02697321216452931\n",
      "valid loss: 0.022047681451006666\n",
      "New best score: 0.022047681451006666\n",
      "\n",
      "Epoch 201: train loss: 0.02698522687659921\n",
      "valid loss: 0.022056757257182577\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 202: train loss: 0.026946473529475098\n",
      "valid loss: 0.022030715746143476\n",
      "New best score: 0.022030715746143476\n",
      "\n",
      "Epoch 203: train loss: 0.026932300859973207\n",
      "valid loss: 0.022023860876870856\n",
      "New best score: 0.022023860876870856\n",
      "\n",
      "Epoch 204: train loss: 0.02693771722661527\n",
      "valid loss: 0.022042856685043685\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 205: train loss: 0.026908298703061904\n",
      "valid loss: 0.022018495143793237\n",
      "New best score: 0.022018495143793237\n",
      "\n",
      "Epoch 206: train loss: 0.026924745706809295\n",
      "valid loss: 0.022006724925986567\n",
      "New best score: 0.022006724925986567\n",
      "\n",
      "Epoch 207: train loss: 0.026879847991720097\n",
      "valid loss: 0.022002845101027946\n",
      "New best score: 0.022002845101027946\n",
      "\n",
      "Epoch 208: train loss: 0.026870596271772188\n",
      "valid loss: 0.021977116728120083\n",
      "New best score: 0.021977116728120083\n",
      "\n",
      "Epoch 209: train loss: 0.026854710156822767\n",
      "valid loss: 0.02197441138439084\n",
      "New best score: 0.02197441138439084\n",
      "\n",
      "Epoch 210: train loss: 0.02684843184023091\n",
      "valid loss: 0.02198466005012434\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 211: train loss: 0.02682978686445658\n",
      "valid loss: 0.021955960517484552\n",
      "New best score: 0.021955960517484552\n",
      "\n",
      "Epoch 212: train loss: 0.02681700668246957\n",
      "valid loss: 0.02195046661609957\n",
      "New best score: 0.02195046661609957\n",
      "\n",
      "Epoch 213: train loss: 0.02680318067153029\n",
      "valid loss: 0.02195493712044153\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 214: train loss: 0.026792003410551376\n",
      "valid loss: 0.02193685938156327\n",
      "New best score: 0.02193685938156327\n",
      "\n",
      "Epoch 215: train loss: 0.026778891367880524\n",
      "valid loss: 0.021936603644710097\n",
      "New best score: 0.021936603644710097\n",
      "\n",
      "Epoch 216: train loss: 0.026765594678266724\n",
      "valid loss: 0.02192195610555469\n",
      "New best score: 0.02192195610555469\n",
      "\n",
      "Epoch 217: train loss: 0.026753041088353153\n",
      "valid loss: 0.0219172972147582\n",
      "New best score: 0.0219172972147582\n",
      "\n",
      "Epoch 218: train loss: 0.026740441359909\n",
      "valid loss: 0.021891815369551787\n",
      "New best score: 0.021891815369551787\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 219: train loss: 0.02675781211188957\n",
      "valid loss: 0.021882710980678923\n",
      "New best score: 0.021882710980678923\n",
      "\n",
      "Epoch 220: train loss: 0.02671727145791417\n",
      "valid loss: 0.02188420647175097\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 221: train loss: 0.026706334428299026\n",
      "valid loss: 0.021876843120200468\n",
      "New best score: 0.021876843120200468\n",
      "\n",
      "Epoch 222: train loss: 0.02669213155113574\n",
      "valid loss: 0.02187243546410133\n",
      "New best score: 0.02187243546410133\n",
      "\n",
      "Epoch 223: train loss: 0.026701319294075265\n",
      "valid loss: 0.021869710195158185\n",
      "New best score: 0.021869710195158185\n",
      "\n",
      "Epoch 224: train loss: 0.026678147293265772\n",
      "valid loss: 0.0218592405571129\n",
      "New best score: 0.0218592405571129\n",
      "\n",
      "Epoch 225: train loss: 0.026663049977819434\n",
      "valid loss: 0.02185935075471147\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 226: train loss: 0.026644339121434744\n",
      "valid loss: 0.021852905498664886\n",
      "New best score: 0.021852905498664886\n",
      "\n",
      "Epoch 227: train loss: 0.026632149542421886\n",
      "valid loss: 0.02184709989964514\n",
      "New best score: 0.02184709989964514\n",
      "\n",
      "Epoch 228: train loss: 0.02662308178784194\n",
      "valid loss: 0.021839073700117853\n",
      "New best score: 0.021839073700117853\n",
      "\n",
      "Epoch 229: train loss: 0.0266067186489801\n",
      "valid loss: 0.021813320899840262\n",
      "New best score: 0.021813320899840262\n",
      "\n",
      "Epoch 230: train loss: 0.026596664046614038\n",
      "valid loss: 0.021812049154182032\n",
      "New best score: 0.021812049154182032\n",
      "\n",
      "Epoch 231: train loss: 0.026586715475234057\n",
      "valid loss: 0.021813731203924436\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 232: train loss: 0.026573514466994862\n",
      "valid loss: 0.021802416847906802\n",
      "New best score: 0.021802416847906802\n",
      "\n",
      "Epoch 233: train loss: 0.026591666917143885\n",
      "valid loss: 0.021827242320881842\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 234: train loss: 0.026551182184370154\n",
      "valid loss: 0.021798279944328907\n",
      "New best score: 0.021798279944328907\n",
      "\n",
      "Epoch 235: train loss: 0.02653926370147238\n",
      "valid loss: 0.021774038161492086\n",
      "New best score: 0.021774038161492086\n",
      "\n",
      "Epoch 236: train loss: 0.026527666771271573\n",
      "valid loss: 0.02177286891042779\n",
      "New best score: 0.02177286891042779\n",
      "\n",
      "Epoch 237: train loss: 0.026515682890564274\n",
      "valid loss: 0.021766722955756254\n",
      "New best score: 0.021766722955756254\n",
      "\n",
      "Epoch 238: train loss: 0.02650503105578328\n",
      "valid loss: 0.021760672808986137\n",
      "New best score: 0.021760672808986137\n",
      "\n",
      "Epoch 239: train loss: 0.02649356088161212\n",
      "valid loss: 0.021760542575229223\n",
      "New best score: 0.021760542575229223\n",
      "\n",
      "Epoch 240: train loss: 0.02648173972860114\n",
      "valid loss: 0.021756782706653894\n",
      "New best score: 0.021756782706653894\n",
      "\n",
      "Epoch 241: train loss: 0.026470260627845563\n",
      "valid loss: 0.021743538932457486\n",
      "New best score: 0.021743538932457486\n",
      "\n",
      "Epoch 242: train loss: 0.02646023950367689\n",
      "valid loss: 0.02173636605291337\n",
      "New best score: 0.02173636605291337\n",
      "\n",
      "Epoch 243: train loss: 0.026447690709718426\n",
      "valid loss: 0.021723229918740893\n",
      "New best score: 0.021723229918740893\n",
      "\n",
      "Epoch 244: train loss: 0.026436533651583567\n",
      "valid loss: 0.02171516716556593\n",
      "New best score: 0.02171516716556593\n",
      "\n",
      "Epoch 245: train loss: 0.026427496995030764\n",
      "valid loss: 0.0217038648508367\n",
      "New best score: 0.0217038648508367\n",
      "\n",
      "Epoch 246: train loss: 0.026415772832677223\n",
      "valid loss: 0.021700024869944393\n",
      "New best score: 0.021700024869944393\n",
      "\n",
      "Epoch 247: train loss: 0.026404477558615146\n",
      "valid loss: 0.021701464606347223\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 248: train loss: 0.0263892589270513\n",
      "valid loss: 0.021680465038061713\n",
      "New best score: 0.021680465038061713\n",
      "\n",
      "Epoch 249: train loss: 0.02640936977428564\n",
      "valid loss: 0.021685087677254213\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 250: train loss: 0.026396438337187595\n",
      "valid loss: 0.021688318406257148\n",
      "2  iterations since best score.\n",
      "\n",
      "Epoch 251: train loss: 0.026359157091190053\n",
      "valid loss: 0.0216866343788538\n",
      "3  iterations since best score.\n",
      "Early stopping\n"
     ]
    }
   ],
   "source": [
    "def training_loop(model,training_generator,valid_generator,optimizer,criterion,max_epochs=100,apply_early_stopping=True,patience=2,verbose=False):\n",
    "    #Setting the model in training mode\n",
    "    model.train()\n",
    "\n",
    "    if apply_early_stopping:\n",
    "        early_stopping = EarlyStopping(verbose=verbose,patience=patience)\n",
    "    \n",
    "    all_train_losses = []\n",
    "    all_valid_losses = []\n",
    "    \n",
    "    #Training loop\n",
    "    start_time=time.time()\n",
    "    for epoch in range(max_epochs):\n",
    "        model.train()\n",
    "        train_loss=[]\n",
    "        for x_batch, y_batch in training_generator:\n",
    "            optimizer.zero_grad()\n",
    "            y_pred = model(x_batch)\n",
    "            loss = criterion(y_pred.squeeze(), y_batch)\n",
    "            loss.backward()\n",
    "            optimizer.step()   \n",
    "            train_loss.append(loss.item())\n",
    "        \n",
    "        #showing last training loss after each epoch\n",
    "        all_train_losses.append(np.mean(train_loss))\n",
    "        if verbose:\n",
    "            print('')\n",
    "            print('Epoch {}: train loss: {}'.format(epoch, np.mean(train_loss)))\n",
    "        #evaluating the model on the test set after each epoch    \n",
    "        valid_loss = evaluate_model(model,valid_generator,criterion)\n",
    "        all_valid_losses.append(valid_loss)\n",
    "        if verbose:\n",
    "            print('valid loss: {}'.format(valid_loss))\n",
    "        if apply_early_stopping:\n",
    "            if not early_stopping.continue_training(valid_loss):\n",
    "                if verbose:\n",
    "                    print(\"Early stopping\")\n",
    "                break\n",
    "        \n",
    "    training_execution_time=time.time()-start_time\n",
    "    return model,training_execution_time,all_train_losses,all_valid_losses\n",
    "\n",
    "model,training_execution_time,train_losses,valid_losses = training_loop(model,training_generator,valid_generator,optimizer,criterion,max_epochs=500,verbose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After 251 epochs, the model stops learning because the validation performance has not improved for three iterations. Here the optimal model (from epoch 248) is not saved, but this could be implemented by simply adding `torch.save(model.state_dict(), checkpoint_path)` in the `EarlyStopping` class whenever a new best performance is reached. This allows reloading the saved best checkpoint at the end of the training. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that a clean optimization process is defined, one can consider several solutions to speed up and improve convergence towards a decent extremum. The most natural way to do so is to play with the optimizer hyperparameters like the learning rate and the batch size. With a large learning rate, gradient descent is fast at the beginning, but then the optimizer struggles to find the minimum. Adaptive learning rate techniques like Adam/RMSProp take into account the steepness by normalizing the learning rate with respect to the gradient norm. Below are the formulas to update on a model parameter $w_t$ with Adam.\n",
    "\n",
    "$w_{t+1} = w_t - \\frac{\\eta}{\\sqrt{\\hat{v_t}+\\epsilon}}*\\hat{m_t}$\n",
    "\n",
    "Where:\n",
    "\n",
    "$m_t = \\beta_1 * m_{t-1} + (1-\\beta_1)*\\nabla w_t$\n",
    "\n",
    "$v_t = \\beta_2 * v_{t-1} + (1-\\beta_2)*(\\nabla w_t)^2$\n",
    "\n",
    "$\\hat{m_t}=\\frac{m_t}{1-\\beta_1^t}$\n",
    "\n",
    "$\\hat{v_t}=\\frac{v_t}{1-\\beta_2^t}$\n",
    "\n",
    "The difference with SGD is that here the learning rate is normalized using the \"gradient norm\" ($\\approx \\hat{m_t}$). To be more precise, the approach does not use the \"raw\" gradient $\\nabla w_t$ and gradient norm $\\nabla w_t^2$ but a momentum instead (convex combination between previous values and the current value), respectively $m_t$ and $v_t$. It also applies a decay over the iterations.\n",
    "\n",
    "Let us try Adam with an initial learning rate of `0.0005` to see the difference with regular SGD. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "tags": [
     "output_scroll"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 0: train loss: 0.04573855715283828\n",
      "valid loss: 0.022921395302963915\n",
      "New best score: 0.022921395302963915\n",
      "\n",
      "Epoch 1: train loss: 0.026701830054725026\n",
      "valid loss: 0.02114229145894957\n",
      "New best score: 0.02114229145894957\n",
      "\n",
      "Epoch 2: train loss: 0.024963660846240854\n",
      "valid loss: 0.020324631678856543\n",
      "New best score: 0.020324631678856543\n",
      "\n",
      "Epoch 3: train loss: 0.023575769497520587\n",
      "valid loss: 0.020667109151543857\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 4: train loss: 0.022709976203506368\n",
      "valid loss: 0.019151893639657136\n",
      "New best score: 0.019151893639657136\n",
      "\n",
      "Epoch 5: train loss: 0.02221683326257877\n",
      "valid loss: 0.01883163772557755\n",
      "New best score: 0.01883163772557755\n",
      "\n",
      "Epoch 6: train loss: 0.021621740234552315\n",
      "valid loss: 0.020071852290392166\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 7: train loss: 0.021379320485157675\n",
      "valid loss: 0.01888933465421668\n",
      "2  iterations since best score.\n",
      "\n",
      "Epoch 8: train loss: 0.020929416735303973\n",
      "valid loss: 0.018099226153906068\n",
      "New best score: 0.018099226153906068\n",
      "\n",
      "Epoch 9: train loss: 0.0205484975132037\n",
      "valid loss: 0.018046115800392268\n",
      "New best score: 0.018046115800392268\n",
      "\n",
      "Epoch 10: train loss: 0.020301625159160407\n",
      "valid loss: 0.01875325692474048\n",
      "1  iterations since best score.\n",
      "\n",
      "Epoch 11: train loss: 0.020031702731716863\n",
      "valid loss: 0.019088358170215466\n",
      "2  iterations since best score.\n",
      "\n",
      "Epoch 12: train loss: 0.019720997269925114\n",
      "valid loss: 0.018150363140039736\n",
      "3  iterations since best score.\n",
      "Early stopping\n"
     ]
    }
   ],
   "source": [
    "seed_everything(SEED)\n",
    "model = SimpleFraudMLP(len(input_features), 1000).to(DEVICE)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr = 0.0005)\n",
    "model,training_execution_time,train_losses_adam,valid_losses_adam = training_loop(model,training_generator,valid_generator,optimizer,criterion,verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.01, 0.06)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(np.arange(len(train_losses))+1, train_losses)\n",
    "plt.plot(np.arange(len(valid_losses))+1, valid_losses)\n",
    "plt.title(\"SGD\")\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')\n",
    "plt.legend(['train','valid'])\n",
    "plt.ylim([0.01,0.06])\n",
    "\n",
    "plt.subplot(1, 2, 2) \n",
    "plt.plot(np.arange(len(train_losses_adam))+1, train_losses_adam)\n",
    "plt.plot(np.arange(len(valid_losses_adam))+1, valid_losses_adam)\n",
    "plt.title(\"ADAM\")\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')\n",
    "plt.legend(['train','valid'])\n",
    "plt.ylim([0.01,0.06])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optimization is much faster with Adam (10 times fewer epochs) and it reaches a better optimum. Of course, increasing patience or changing the learning rate with SGD would probably help improve both speed and optimum. Nevertheless, Adam will be retained for the rest of the chapter as it usually allows very decent performance **without significant tuning**. To build the final neural network later, the tuning will mostly be made using batch size and initial learning rate. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are only mentioned the optimizer's choice and some hyperparameters tuning for the optimization process. But keep in mind that neural network optimization is a very wide and active area of research/engineering. For instance, with Deep Networks, one can apply batch normalization after each layer to standardize the distribution and speed up convergence. One can also reduce the learning rate when validation loss reaches a plateau (`torch.optim.ReduceLROnPlateau`). For a full guide on Deep Learning optimization, we recommend {cite}`ruder2016overview,le2011optimization`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regularization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A classical way to improve generalization and reach a better validation performance is to regularize the model. Roughly speaking, regularization consists in limiting the model expressiveness in order to reduce overfitting. \n",
    "\n",
    "The most common technique to regularize a machine learning model is to restrict its parameter space, for instance, its norm, by adding a term in the optimization problem. Additionally, to minimize the discrepancy between ground truth and prediction, integrating an L1 norm (resp. L2 norm) term in the loss will entail parameter sparsity (resp. will limit parameters amplitude). The initial solution space is generally full of equivalent solutions (e.g. with linear activations, dividing all input weights of a neuron by 2 and multiplying all of its output weights by 2 leads to an equivalent model), so the restrictions entailed by regularization not only limits overfitting but also reduces the search and can help with optimization. Finally, selecting a solution with minimal norm follows the principle of \"All things being equal, the simplest solution tends to be the best one\", a scientific principle often referred to as the [Occam's razor](https://en.wikipedia.org/wiki/Occam's_razor).\n",
    "\n",
    "In contrast to adding loss terms, there is a regularization technique specifically designed for Neural Networks called dropout. Dropout consists in randomly dropping some neurons from the network at each training step. More precisely, one fixes a dropout parameter p∈[0,1], and, for each mini-batch, for each neuron, performs a coin toss (Bernoulli) with probability p. If positive, one temporarily sets the neuron's weights to zero (so that the dropped neuron is not considered during the forward and backward passes). It is equivalent to training a random sub-network at each mini-batch (Figure 5), and it can be proven that this has an L2-regularization effect on specific architectures {cite}`srivastava2014dropout`.\n",
    "\n",
    "![alt text](./images/dropout.png)\n",
    "Image source: {cite}`srivastava2014dropout`\n",
    "\n",
    "To implement it, let us define a new model with an additional `torch.nn.Dropout` layer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleFraudMLPWithDropout(torch.nn.Module):\n",
    "    \n",
    "        def __init__(self, input_size, hidden_size,p):\n",
    "            super(SimpleFraudMLPWithDropout, self).__init__()\n",
    "            # parameters\n",
    "            self.input_size = input_size\n",
    "            self.hidden_size  = hidden_size\n",
    "            self.p = p\n",
    "            \n",
    "            #input to hidden\n",
    "            self.fc1 = torch.nn.Linear(self.input_size, self.hidden_size)\n",
    "            self.relu = torch.nn.ReLU()\n",
    "            #hidden to output\n",
    "            self.fc2 = torch.nn.Linear(self.hidden_size, 1)\n",
    "            self.sigmoid = torch.nn.Sigmoid()\n",
    "            \n",
    "            self.dropout = torch.nn.Dropout(self.p)\n",
    "            \n",
    "        def forward(self, x):\n",
    "            \n",
    "            hidden = self.fc1(x)\n",
    "            hidden = self.relu(hidden)\n",
    "            \n",
    "            hidden = self.dropout(hidden)\n",
    "            \n",
    "            output = self.fc2(hidden)\n",
    "            output = self.sigmoid(output)\n",
    "            \n",
    "            return output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that setting the model in training/evaluation mode with the methods `model.eval()` and `model.train()` take all its significance here. In particular, the dropout layer in the forward pass is only applied when the model is in training mode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed_everything(SEED)\n",
    "model = SimpleFraudMLPWithDropout(len(input_features), 1000,0.2).to(DEVICE)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr = 0.0005)\n",
    "model,training_execution_time,train_losses_dropout,valid_losses_dropout = training_loop(model,training_generator,valid_generator,optimizer,criterion,verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f996d2e3190>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.arange(len(train_losses_adam))+1, train_losses_adam)\n",
    "plt.plot(np.arange(len(valid_losses_adam))+1, valid_losses_adam)\n",
    "plt.plot(np.arange(len(train_losses_dropout))+1, train_losses_dropout)\n",
    "plt.plot(np.arange(len(valid_losses_dropout))+1, valid_losses_dropout)\n",
    "plt.title(\"Dropout effect\")\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')\n",
    "plt.legend(['train w/o dropout','valid w/o dropout','train w/ dropout','valid w/ dropout'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is generally reported that a small dropout value can lead to better generalization results than no dropout, but it can sometimes be the opposite if the training data are very rich, if the training distribution is close to the valid/test distribution, and if the model is already not too expressive. So, the best practice is to consider dropout as a hyperparameter (that could be set to 0) and tune it with a hyperparameter search. \n",
    "\n",
    "In addition to the L2-regularization effect, dropout can be seen as a very powerful mechanism that mimics ensembling strategies like bagging (the model can be seen as an ensemble of submodels trained on different subsets of data) {cite}`goodfellow2016deep`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scaling the inputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "XGBoost and random forests learn splits on single features and therefore are robust to the scale and distribution of the values. On the contrary, in a neural network, each neuron of the first layer learns a linear combination of all the features. Therefore, it is easier to train the neurons when all features have the same range and are normally distributed. The first property can be easily implemented by applying min-max or standard scaling on the features. As for the second property, it depends on the original distribution of the features. Some of them are not normally distributed and have non-linear scales (e.g. amount): increasing the amount by 5 dollars should not have the same effect if the starting point is 5 dollars or if the starting point is 100 dollars. It turns out that applying the log function on such features can make their distribution slightly more normal which makes it easier for feed-forward neural networks to learn from them. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "(train_df, valid_df)=get_train_test_set(transactions_df,start_date_training_with_valid,\n",
    "                                       delta_train=delta_train,delta_delay=delta_delay,delta_test=delta_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For instance here is how the original amounts look like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_ = plt.hist(train_df['TX_AMOUNT'].values,bins=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now let us apply the log function to it. To obtain a positive log for the feature that is in [0,+∞[, an idea is to add 1 and then apply the log function (which is equivalent to applying the `log1p` function in `numpy`). This leads to a preprocessed feature that belongs to [0,+∞[ and it can then be standardized. Here is how the amounts are distributed after all these steps:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "_ = plt.hist(sklearn.preprocessing.StandardScaler().fit_transform(np.log1p(train_df['TX_AMOUNT'].values).reshape(-1, 1)),bins=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that here, our artificial data were generated with Gaussians so the `np.log1p` is not very useful in practice. But keep in mind that on real-world data, the original scale of features like amount is far from normally distributed and this operation turns out to be quite often useful. \n",
    "\n",
    "Let us forget about the log for now and just analyze the impact of scaling the features on our Neural Network's training. More precisely, let us see the difference between no scaling at all and standard scaling. A smaller learning rate of `0.0001` will be chosen here for the experiment without scaling to avoid divergence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "#we did not call the function scaleData this time\n",
    "seed_everything(SEED)\n",
    "training_generator,valid_generator = prepare_generators(train_df,valid_df,batch_size=64)\n",
    "\n",
    "model = SimpleFraudMLPWithDropout(len(input_features), 1000,0.2).to(DEVICE)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr = 0.0001)\n",
    "model,training_execution_time,train_losses_without_scaling,valid_losses_without_scaling = training_loop(model,training_generator,valid_generator,optimizer,criterion,verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f9917b62c70>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.arange(len(train_losses_without_scaling))+1, train_losses_without_scaling)\n",
    "plt.plot(np.arange(len(valid_losses_without_scaling))+1, valid_losses_without_scaling)\n",
    "plt.plot(np.arange(len(train_losses_dropout))+1, train_losses_dropout)\n",
    "plt.plot(np.arange(len(valid_losses_dropout))+1, valid_losses_dropout)\n",
    "plt.title('Scaling effect')\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')\n",
    "plt.legend(['train w/o scaling','valid w/o scaling','train w/ scaling','valid w/ scaling'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The train/valid losses are smoother and reach much better levels faster when the data is normalized with standard scaling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let us rescale data for the next parts\n",
    "(train_df, valid_df)=scaleData(train_df, valid_df,input_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Embeddings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Properly taking into account categorical variables is maybe one of the main advantages of neural networks. In the first chapters, [feature transformation techniques](Baseline_Feature_Transformation) were applied to categorical features like day, Customer ID, Terminal ID, in order to make them binary or to extract numerical features from them. \n",
    "\n",
    "In real-world data, categorical features are frequent (Country, Merchant Type, hour, type of payment, ...). But most machine learning algorithms require features to be numerical. Take the example of linear regression: it is basically a weighted sum of the features' values. For numerical features, it makes sense to consider that their impact is proportional to their value (e.g. the smaller the delay between two transactions, the higher the fraud risk), but it does not make sense for a nominal feature like a Country that can take the values \"USA\", \"France\", \"Belgium\". For the latter, a transformation is necessary. The most common choices are:\n",
    "\n",
    "* One-hot encoding: a binary feature is defined for each modality (e.g. \"country_is_USA\", \"country_is_France\" and \"country_is_Belgium\").\n",
    "* Frequency-based encoding: The frequency (or another statistic) of each modality is computed and the index of the modality is replaced with the value of the statistic. \n",
    "* Label-correlation encoding: It is close to frequency encoding but here a statistic correlated with the label is computed. For instance, each modality can be replaced with its proportion of fraud in the training data. \n",
    "\n",
    "With neural networks, one can make use of embedding layers to encode categorical variables. More precisely, the idea is to let the neural network itself learn a representation of each modality of the categorical variable in a continuous vector space of dimension k, chosen by the practitioner. These representations can be learned end-to-end to make the feed-forward network optimal for the fraud detection task. They can also be learned with a different objective like predicting the sequences of countries visited by cardholders (unsupervised pre-training) and then later used for fraud detection, either with a neural network classifier or any other classifier (XGBoost, random forest, etc.). \n",
    "\n",
    "![Embedding layer illustration](./images/embedding.png)\n",
    "\n",
    "Note that learning an embedding of dimension $k$ for a categorical feature is computationally equivalent to learning a classical fully connected layer that takes as input the one-hot encoding of the feature and outputs $k$ neurons.\n",
    "\n",
    "To test embedding layers, let us try to add extra categorical inputs in $x$ and let the model learn embedding for them. Our last neural network was trained on the following features:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['TX_AMOUNT',\n",
       " 'TX_DURING_WEEKEND',\n",
       " 'TX_DURING_NIGHT',\n",
       " 'CUSTOMER_ID_NB_TX_1DAY_WINDOW',\n",
       " 'CUSTOMER_ID_AVG_AMOUNT_1DAY_WINDOW',\n",
       " 'CUSTOMER_ID_NB_TX_7DAY_WINDOW',\n",
       " 'CUSTOMER_ID_AVG_AMOUNT_7DAY_WINDOW',\n",
       " 'CUSTOMER_ID_NB_TX_30DAY_WINDOW',\n",
       " 'CUSTOMER_ID_AVG_AMOUNT_30DAY_WINDOW',\n",
       " 'TERMINAL_ID_NB_TX_1DAY_WINDOW',\n",
       " 'TERMINAL_ID_RISK_1DAY_WINDOW',\n",
       " 'TERMINAL_ID_NB_TX_7DAY_WINDOW',\n",
       " 'TERMINAL_ID_RISK_7DAY_WINDOW',\n",
       " 'TERMINAL_ID_NB_TX_30DAY_WINDOW',\n",
       " 'TERMINAL_ID_RISK_30DAY_WINDOW']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input_features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us add, for example, the raw terminal id and the day of the week as categorical input features:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weekday(tx_datetime):\n",
    "    \n",
    "    # Transform date into weekday (0 is Monday, 6 is Sunday)\n",
    "    weekday = tx_datetime.weekday()\n",
    "    \n",
    "    return int(weekday)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_df['TX_WEEKDAY'] = train_df.TX_DATETIME.apply(weekday)\n",
    "valid_df['TX_WEEKDAY'] = valid_df.TX_DATETIME.apply(weekday)\n",
    "input_categorical_features = ['TX_WEEKDAY','TERMINAL_ID']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us now define a new neural network model with two embedding layers. `TX_WEEKDAY` and `TERMINAL_ID` will both go through one of them, and each will be turned into a vector. Then they will be concatenated with the numerical features and the whole will go through a network similar to our previous architecture."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FraudMLPWithEmbedding(torch.nn.Module):\n",
    "    \n",
    "        def __init__(self, categorical_inputs_modalities,numerical_inputs_size,embedding_sizes, hidden_size,p):\n",
    "            super(FraudMLPWithEmbedding, self).__init__()\n",
    "            # parameters\n",
    "            self.categorical_inputs_modalities = categorical_inputs_modalities\n",
    "            self.numerical_inputs_size = numerical_inputs_size\n",
    "            self.embedding_sizes = embedding_sizes\n",
    "            self.hidden_size  = hidden_size\n",
    "            self.p = p\n",
    "            \n",
    "            assert len(categorical_inputs_modalities)==len(embedding_sizes), 'categorical_inputs_modalities and embedding_sizes must have the same length'\n",
    "            \n",
    "            #embedding layers\n",
    "            self.emb = []\n",
    "            for i in range(len(categorical_inputs_modalities)):\n",
    "                self.emb.append(torch.nn.Embedding(int(categorical_inputs_modalities[i]), int(embedding_sizes[i])).to(DEVICE))\n",
    "                \n",
    "            \n",
    "            #contenated inputs to hidden\n",
    "            self.fc1 = torch.nn.Linear(self.numerical_inputs_size+int(np.sum(embedding_sizes)), self.hidden_size)\n",
    "            self.relu = torch.nn.ReLU()\n",
    "            #hidden to output\n",
    "            self.fc2 = torch.nn.Linear(self.hidden_size, 1)\n",
    "            self.sigmoid = torch.nn.Sigmoid()\n",
    "            \n",
    "            self.dropout = torch.nn.Dropout(self.p)\n",
    "            \n",
    "        def forward(self, x):\n",
    "            #we assume that x start with numerical features then categorical features\n",
    "            inputs = [x[:,:self.numerical_inputs_size]]\n",
    "            for i in range(len(self.categorical_inputs_modalities)):\n",
    "                inputs.append(self.emb[i](x[:,self.numerical_inputs_size+i].to(torch.int64)))\n",
    "            \n",
    "            x = torch.cat(inputs,axis=1)\n",
    "            \n",
    "            \n",
    "            hidden = self.fc1(x)\n",
    "            hidden = self.relu(hidden)\n",
    "            \n",
    "            hidden = self.dropout(hidden)\n",
    "            \n",
    "            output = self.fc2(hidden)\n",
    "            output = self.sigmoid(output)\n",
    "            \n",
    "            return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_generators_with_categorical_features(train_df,valid_df,input_categorical_features,batch_size=64):\n",
    "    x_train = torch.FloatTensor(train_df[input_features].values)\n",
    "    x_valid = torch.FloatTensor(valid_df[input_features].values)\n",
    "    y_train = torch.FloatTensor(train_df[output_feature].values)\n",
    "    y_valid = torch.FloatTensor(valid_df[output_feature].values)\n",
    "    \n",
    "    #categorical variables : encoding valid according to train\n",
    "    encoder = sklearn.preprocessing.OrdinalEncoder(handle_unknown='use_encoded_value',unknown_value=-1)\n",
    "    x_train_cat = encoder.fit_transform(train_df[input_categorical_features].values) + 1\n",
    "    categorical_inputs_modalities = np.max(x_train_cat,axis=0)+1\n",
    "    \n",
    "    x_train_cat = torch.IntTensor(x_train_cat)\n",
    "    x_valid_cat = torch.IntTensor(encoder.transform(valid_df[input_categorical_features].values) + 1)\n",
    "    \n",
    "    x_train = torch.cat([x_train,x_train_cat],axis=1)\n",
    "    x_valid = torch.cat([x_valid,x_valid_cat],axis=1)\n",
    "    \n",
    "    train_loader_params = {'batch_size': batch_size,\n",
    "              'shuffle': True,\n",
    "              'num_workers': 0}\n",
    "    valid_loader_params = {'batch_size': batch_size,\n",
    "              'num_workers': 0}\n",
    "    \n",
    "    # Generators\n",
    "    training_set = FraudDataset(x_train, y_train)\n",
    "    valid_set = FraudDataset(x_valid, y_valid)\n",
    "    \n",
    "    training_generator = torch.utils.data.DataLoader(training_set, **train_loader_params)\n",
    "    valid_generator = torch.utils.data.DataLoader(valid_set, **valid_loader_params)\n",
    "    \n",
    "    return training_generator,valid_generator, categorical_inputs_modalities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let us train this new model with an embedding dimension of 10 for each categorical feature. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed_everything(SEED)\n",
    "training_generator,valid_generator,categorical_inputs_modalities = prepare_generators_with_categorical_features(train_df,valid_df,input_categorical_features,batch_size=64)\n",
    "\n",
    "embedding_sizes = [10]*len(categorical_inputs_modalities)\n",
    "\n",
    "model = FraudMLPWithEmbedding(categorical_inputs_modalities,len(input_features),embedding_sizes, 1000,0.2).to(DEVICE)\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr = 0.0001)\n",
    "model,training_execution_time,train_losses_embedding,valid_losses_embedding = training_loop(model,training_generator,valid_generator,optimizer,criterion,verbose=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f9917ac37c0>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(np.arange(len(train_losses_embedding))+1, train_losses_embedding)\n",
    "plt.plot(np.arange(len(valid_losses_embedding))+1, valid_losses_embedding)\n",
    "plt.plot(np.arange(len(train_losses_dropout))+1, train_losses_dropout)\n",
    "plt.plot(np.arange(len(valid_losses_dropout))+1, valid_losses_dropout)\n",
    "plt.title('Use of categorical features')\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('loss')\n",
    "plt.legend(['train w/ cat','valid w/ cat','train w/o cat','valid w/o cat'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The performance here is not necessarily better with the categorical features (they do not add value compared to the engineered features, at least for the fraud patterns in our categorical data). This implementation is shown for educational purposes. Keep in mind that embedding layers are often a valuable solution in practice when training with a lot of data because it is a step forward in automation (instead of expert feature engineering, one can leave the representation choice to the model). \n",
    "\n",
    "Embedding can also be interesting for interpretability. Indeed, at the end of training, one can extract `model.emb[i].weight`. Each row of this matrix represents the embedding vector of a given modality for the `i-th` categorical feature. This can be used to compute similarities between modalities. One can also reduce these vectors' dimensionality with TSNE or PCA and visualize all modalities on a 2D plane."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ensemble"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To go further and improve the results, ensembling is a common strategy with neural networks in general and for fraud detection. \n",
    "\n",
    "The idea is to simply train the architecture several times and average the predictions of all the obtained models at inference {cite}`zhou2021ensemble`. Layer initialization and the random batch order are generally enough to ensure diversity between each submodel and make the ensemble better than each individual. To go further, one can also train each individual on a different train/valid split {cite}`breiman1996bagging`.\n",
    "\n",
    "Ensembling is also very useful for fraud detection, in particular, because of concept drift. Indeed, in fraud detection, the fraudsters' techniques are varied and change over time. A single model can struggle to both learn and remember all the different patterns for the target class. In this context, it is expected that an ensemble of models, efficiently built, can cope with the issue. The intuition is that the different components of the ensemble can be specialized for different tasks. For example, a component could be specialized for the recent patterns and another for the old patterns {cite}`lebichot2021incremental`. Similarly, a component could be specialized for the easiest and generic fraudsters’ strategies and another for advanced concepts."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Model_Selection_FFNN)=\n",
    "## Prequential grid search"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above sections have shown many design choices for the neural network. Let us now follow the prequential methodology from Chapter 5 and perform a grid search to see the impact of some hyperparameters on the performance and be able to compare the results with other baselines from previous chapters.\n",
    "\n",
    "Let us consider the following ranges:\n",
    "* Batch size : [64,128,256]\n",
    "* Initial learning rate: [0.0001, 0.0002, 0.001]\n",
    "* Dropout rate : [0, 0.2, 0.4]\n",
    "* Hidden layer dimension : [500]\n",
    "* Number of hidden layers : [1,2]\n",
    "\n",
    "To use the same procedure as in previous chapters (with GridSearchCV), we have to make the neural network compatible with `sklearn` functions. We will resort to the library `skorch`, which provides an `sklearn` wrapper for `PyTorch` modules. Also, early stopping won't be used, but instead the number of epochs ([10,20,40]) will be another parameter to search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "tags": [
     "hide-output"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: skorch in /opt/conda/lib/python3.8/site-packages (0.10.0)\n",
      "Requirement already satisfied: numpy>=1.13.3 in /opt/conda/lib/python3.8/site-packages (from skorch) (1.19.2)\n",
      "Requirement already satisfied: scipy>=1.1.0 in /opt/conda/lib/python3.8/site-packages (from skorch) (1.6.3)\n",
      "Requirement already satisfied: tqdm>=4.14.0 in /opt/conda/lib/python3.8/site-packages (from skorch) (4.51.0)\n",
      "Requirement already satisfied: scikit-learn>=0.19.1 in /opt/conda/lib/python3.8/site-packages (from skorch) (0.24.2)\n",
      "Requirement already satisfied: tabulate>=0.7.7 in /opt/conda/lib/python3.8/site-packages (from skorch) (0.8.9)\n",
      "Requirement already satisfied: threadpoolctl>=2.0.0 in /opt/conda/lib/python3.8/site-packages (from scikit-learn>=0.19.1->skorch) (2.1.0)\n",
      "Requirement already satisfied: joblib>=0.11 in /opt/conda/lib/python3.8/site-packages (from scikit-learn>=0.19.1->skorch) (1.0.1)\n"
     ]
    }
   ],
   "source": [
    "!pip install skorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "from skorch import NeuralNetClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to make this work, several aspects of our previous Python classes have to be adapted. First, `sklearn`'s classifiers have two output probabilities (one for each class) that are complementary. Therefore, the output of `fc2` has to be changed to 2, and the activation to `softmax` (similar to the sigmoid activation but with a global normalization). Second, the dataset has to expect arrays instead of tensors, so the conversion will be done within the dataset. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FraudMLP(torch.nn.Module):\n",
    "    \n",
    "        def __init__(self, hidden_size=100,num_layers=1,p=0, input_size=len(input_features)):\n",
    "            super(FraudMLP, self).__init__()\n",
    "            # parameters\n",
    "            self.input_size = input_size\n",
    "            self.hidden_size  = hidden_size\n",
    "            self.p = p\n",
    "            \n",
    "            #input to hidden\n",
    "            self.fc1 = torch.nn.Linear(self.input_size, self.hidden_size)\n",
    "            self.relu = torch.nn.ReLU()\n",
    "            \n",
    "            self.fc_hidden=[]\n",
    "            for i in range(num_layers-1):\n",
    "                self.fc_hidden.append(torch.nn.Linear(self.hidden_size, self.hidden_size))\n",
    "                self.fc_hidden.append(torch.nn.ReLU())\n",
    "                \n",
    "            #hidden to output\n",
    "            self.fc2 = torch.nn.Linear(self.hidden_size, 2)\n",
    "            self.softmax = torch.nn.Softmax()\n",
    "            \n",
    "            self.dropout = torch.nn.Dropout(self.p)\n",
    "            \n",
    "        def forward(self, x):\n",
    "            \n",
    "            hidden = self.fc1(x)\n",
    "            hidden = self.relu(hidden)             \n",
    "            hidden = self.dropout(hidden)\n",
    "            \n",
    "            for layer in self.fc_hidden:\n",
    "                hidden=layer(hidden)\n",
    "                hidden = self.dropout(hidden)\n",
    "            \n",
    "            output = self.fc2(hidden)\n",
    "            output = self.softmax(output)\n",
    "            \n",
    "            return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FraudDatasetForPipe(torch.utils.data.Dataset):\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        'Initialization'\n",
    "        self.x = torch.FloatTensor(x)\n",
    "        self.y = None\n",
    "        if y is not None:\n",
    "            self.y = torch.LongTensor(y.values)\n",
    "        \n",
    "\n",
    "    def __len__(self):\n",
    "        'Returns the total number of samples'\n",
    "        return len(self.x)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generates one sample of data'\n",
    "        # Select sample index\n",
    "        if self.y is not None:\n",
    "            return self.x[index], self.y[index]\n",
    "        else:\n",
    "            return self.x[index], -1       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that the module and Dataset are adapted, one can obtain an \"sklearn-like\" model using the `NeuralNetClassifier` wrapper from `skorch`. Note that we can set the device directly as a parameter in that class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<class 'skorch.classifier.NeuralNetClassifier'>[uninitialized](\n",
       "  module=<class '__main__.FraudMLP'>,\n",
       ")"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "net = NeuralNetClassifier(\n",
    "    FraudMLP,\n",
    "    max_epochs=2,\n",
    "    lr=0.001,\n",
    "    optimizer=torch.optim.Adam,\n",
    "    batch_size=64,\n",
    "    dataset=FraudDatasetForPipe,\n",
    "    iterator_train__shuffle=True\n",
    ")\n",
    "net.set_params(train_split=False, verbose=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To test it, let us perform a first small grid search by playing on the number of epochs and number of layers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Testing the wrapper\n",
    "\n",
    "#X=train_df[input_features].values\n",
    "#y=train_df[output_feature]\n",
    "#\n",
    "#net.fit(X, y)\n",
    "#net.predict_proba(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Only keep columns that are needed as argument to custom scoring function\n",
    "# to reduce serialization time of transaction dataset\n",
    "transactions_df_scorer=transactions_df[['CUSTOMER_ID', 'TX_FRAUD','TX_TIME_DAYS']]\n",
    "\n",
    "# Make scorer using card_precision_top_k_custom\n",
    "card_precision_top_100 = sklearn.metrics.make_scorer(card_precision_top_k_custom, \n",
    "                                                     needs_proba=True, \n",
    "                                                     top_k=100, \n",
    "                                                     transactions_df=transactions_df_scorer)\n",
    "\n",
    "n_folds=4\n",
    "start_date_training_for_valid = start_date_training+datetime.timedelta(days=-(delta_delay+delta_valid))\n",
    "start_date_training_for_test = start_date_training+datetime.timedelta(days=(n_folds-1)*delta_test)\n",
    "delta_assessment = delta_valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Validation: Total execution time: 37.16s\n"
     ]
    }
   ],
   "source": [
    "seed_everything(SEED)\n",
    "start_time=time.time()\n",
    "\n",
    "parameters = {\n",
    "    'clf__lr': [0.001 ],\n",
    "    'clf__batch_size': [64],\n",
    "    'clf__max_epochs': [10, 20],\n",
    "    'clf__module__hidden_size': [100],\n",
    "    'clf__module__num_layers': [1,2],\n",
    "    'clf__module__p': [0],\n",
    "}\n",
    "\n",
    "scoring = {'roc_auc':'roc_auc',\n",
    "           'average_precision': 'average_precision',\n",
    "           'card_precision@100': card_precision_top_100,\n",
    "           }\n",
    "\n",
    "\n",
    "performance_metrics_list_grid=['roc_auc', 'average_precision', 'card_precision@100']\n",
    "performance_metrics_list=['AUC ROC', 'Average precision', 'Card Precision@100']\n",
    "\n",
    "performances_df_validation=prequential_grid_search(\n",
    "    transactions_df, net, \n",
    "    input_features, output_feature,\n",
    "    parameters, scoring, \n",
    "    start_date_training=start_date_training_with_valid,\n",
    "    n_folds=n_folds,\n",
    "    expe_type='Validation',\n",
    "    delta_train=delta_train, \n",
    "    delta_delay=delta_delay, \n",
    "    delta_assessment=delta_valid,\n",
    "    performance_metrics_list_grid=performance_metrics_list_grid,\n",
    "    performance_metrics_list=performance_metrics_list)\n",
    "\n",
    "print(\"Validation: Total execution time: \"+str(round(time.time()-start_time,2))+\"s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AUC ROC Validation</th>\n",
       "      <th>AUC ROC Validation Std</th>\n",
       "      <th>Average precision Validation</th>\n",
       "      <th>Average precision Validation Std</th>\n",
       "      <th>Card Precision@100 Validation</th>\n",
       "      <th>Card Precision@100 Validation Std</th>\n",
       "      <th>Parameters</th>\n",
       "      <th>Execution time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.876016</td>\n",
       "      <td>0.013714</td>\n",
       "      <td>0.664448</td>\n",
       "      <td>0.011927</td>\n",
       "      <td>0.280714</td>\n",
       "      <td>0.014621</td>\n",
       "      <td>{'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...</td>\n",
       "      <td>17.007030</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.878834</td>\n",
       "      <td>0.015987</td>\n",
       "      <td>0.664845</td>\n",
       "      <td>0.017734</td>\n",
       "      <td>0.285000</td>\n",
       "      <td>0.012227</td>\n",
       "      <td>{'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...</td>\n",
       "      <td>18.879923</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.880894</td>\n",
       "      <td>0.009318</td>\n",
       "      <td>0.682133</td>\n",
       "      <td>0.004213</td>\n",
       "      <td>0.282857</td>\n",
       "      <td>0.013590</td>\n",
       "      <td>{'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...</td>\n",
       "      <td>29.965765</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.879129</td>\n",
       "      <td>0.007107</td>\n",
       "      <td>0.680034</td>\n",
       "      <td>0.010408</td>\n",
       "      <td>0.283571</td>\n",
       "      <td>0.014160</td>\n",
       "      <td>{'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...</td>\n",
       "      <td>33.341235</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   AUC ROC Validation  AUC ROC Validation Std  Average precision Validation  \\\n",
       "0            0.876016                0.013714                      0.664448   \n",
       "1            0.878834                0.015987                      0.664845   \n",
       "2            0.880894                0.009318                      0.682133   \n",
       "3            0.879129                0.007107                      0.680034   \n",
       "\n",
       "   Average precision Validation Std  Card Precision@100 Validation  \\\n",
       "0                          0.011927                       0.280714   \n",
       "1                          0.017734                       0.285000   \n",
       "2                          0.004213                       0.282857   \n",
       "3                          0.010408                       0.283571   \n",
       "\n",
       "   Card Precision@100 Validation Std  \\\n",
       "0                           0.014621   \n",
       "1                           0.012227   \n",
       "2                           0.013590   \n",
       "3                           0.014160   \n",
       "\n",
       "                                          Parameters  Execution time  \n",
       "0  {'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...       17.007030  \n",
       "1  {'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...       18.879923  \n",
       "2  {'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...       29.965765  \n",
       "3  {'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...       33.341235  "
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performances_df_validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Validation seems to be running smoothly and the results already look promising. \n",
    "\n",
    "Let us now perform a proper model selection using the protocol from Chapter 5.3, [](Model_Selection)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed_everything(SEED)\n",
    "\n",
    "\n",
    "parameters = {\n",
    "    'clf__lr': [0.001 , 0.0001, 0.0002],\n",
    "    'clf__batch_size': [64,128,256],\n",
    "    'clf__max_epochs': [10,20,40],\n",
    "    'clf__module__hidden_size': [500],\n",
    "    'clf__module__num_layers': [1,2],\n",
    "    'clf__module__p': [0,0.2,0.4],\n",
    "    'clf__module__input_size': [int(len(input_features))],\n",
    "}\n",
    "\n",
    "start_time=time.time()\n",
    "\n",
    "performances_df=model_selection_wrapper(transactions_df, net, \n",
    "                                        input_features, output_feature,\n",
    "                                        parameters, scoring, \n",
    "                                        start_date_training_for_valid,\n",
    "                                        start_date_training_for_test,\n",
    "                                        n_folds=n_folds,\n",
    "                                        delta_train=delta_train, \n",
    "                                        delta_delay=delta_delay, \n",
    "                                        delta_assessment=delta_assessment,\n",
    "                                        performance_metrics_list_grid=performance_metrics_list_grid,\n",
    "                                        performance_metrics_list=performance_metrics_list,\n",
    "                                        n_jobs=10)\n",
    "\n",
    "\n",
    "execution_time_nn = time.time()-start_time\n",
    "\n",
    "parameters_dict=dict(performances_df['Parameters'])\n",
    "performances_df['Parameters summary']=[str(parameters_dict[i]['clf__lr'])+\n",
    "                                   '/'+\n",
    "                                   str(parameters_dict[i]['clf__batch_size'])+\n",
    "                                   '/'+\n",
    "                                   str(parameters_dict[i]['clf__max_epochs'])+\n",
    "                                   '/'+\n",
    "                                   str(parameters_dict[i]['clf__module__p'])+\n",
    "                                   '/'+\n",
    "                                   str(parameters_dict[i]['clf__module__num_layers'])\n",
    "                                   for i in range(len(parameters_dict))]\n",
    "\n",
    "performances_df_nn=performances_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AUC ROC Test</th>\n",
       "      <th>AUC ROC Test Std</th>\n",
       "      <th>Average precision Test</th>\n",
       "      <th>Average precision Test Std</th>\n",
       "      <th>Card Precision@100 Test</th>\n",
       "      <th>Card Precision@100 Test Std</th>\n",
       "      <th>Parameters</th>\n",
       "      <th>Execution time</th>\n",
       "      <th>AUC ROC Validation</th>\n",
       "      <th>AUC ROC Validation Std</th>\n",
       "      <th>Average precision Validation</th>\n",
       "      <th>Average precision Validation Std</th>\n",
       "      <th>Card Precision@100 Validation</th>\n",
       "      <th>Card Precision@100 Validation Std</th>\n",
       "      <th>Parameters summary</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.873863</td>\n",
       "      <td>0.012930</td>\n",
       "      <td>0.660331</td>\n",
       "      <td>0.018567</td>\n",
       "      <td>0.295714</td>\n",
       "      <td>0.012247</td>\n",
       "      <td>{'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...</td>\n",
       "      <td>19.616337</td>\n",
       "      <td>0.878319</td>\n",
       "      <td>0.008551</td>\n",
       "      <td>0.681225</td>\n",
       "      <td>0.010486</td>\n",
       "      <td>0.282500</td>\n",
       "      <td>0.017332</td>\n",
       "      <td>0.001/64/10/0/1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.877067</td>\n",
       "      <td>0.015960</td>\n",
       "      <td>0.664257</td>\n",
       "      <td>0.012613</td>\n",
       "      <td>0.299286</td>\n",
       "      <td>0.013344</td>\n",
       "      <td>{'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...</td>\n",
       "      <td>21.360825</td>\n",
       "      <td>0.877727</td>\n",
       "      <td>0.009484</td>\n",
       "      <td>0.680278</td>\n",
       "      <td>0.014400</td>\n",
       "      <td>0.283571</td>\n",
       "      <td>0.013942</td>\n",
       "      <td>0.001/64/10/0.2/1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.875579</td>\n",
       "      <td>0.010993</td>\n",
       "      <td>0.666796</td>\n",
       "      <td>0.017888</td>\n",
       "      <td>0.297500</td>\n",
       "      <td>0.017420</td>\n",
       "      <td>{'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...</td>\n",
       "      <td>21.311841</td>\n",
       "      <td>0.875632</td>\n",
       "      <td>0.012137</td>\n",
       "      <td>0.673602</td>\n",
       "      <td>0.010394</td>\n",
       "      <td>0.278571</td>\n",
       "      <td>0.014033</td>\n",
       "      <td>0.001/64/10/0.4/1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.869641</td>\n",
       "      <td>0.016830</td>\n",
       "      <td>0.665317</td>\n",
       "      <td>0.013019</td>\n",
       "      <td>0.296071</td>\n",
       "      <td>0.015563</td>\n",
       "      <td>{'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...</td>\n",
       "      <td>37.053668</td>\n",
       "      <td>0.874913</td>\n",
       "      <td>0.008695</td>\n",
       "      <td>0.671733</td>\n",
       "      <td>0.007931</td>\n",
       "      <td>0.281429</td>\n",
       "      <td>0.012897</td>\n",
       "      <td>0.001/64/10/0/2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.875821</td>\n",
       "      <td>0.012659</td>\n",
       "      <td>0.668085</td>\n",
       "      <td>0.015381</td>\n",
       "      <td>0.301071</td>\n",
       "      <td>0.016732</td>\n",
       "      <td>{'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...</td>\n",
       "      <td>42.327613</td>\n",
       "      <td>0.880785</td>\n",
       "      <td>0.014945</td>\n",
       "      <td>0.671497</td>\n",
       "      <td>0.012921</td>\n",
       "      <td>0.282500</td>\n",
       "      <td>0.015365</td>\n",
       "      <td>0.001/64/10/0.2/2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>157</th>\n",
       "      <td>0.875426</td>\n",
       "      <td>0.012132</td>\n",
       "      <td>0.658144</td>\n",
       "      <td>0.013130</td>\n",
       "      <td>0.297500</td>\n",
       "      <td>0.013529</td>\n",
       "      <td>{'clf__batch_size': 256, 'clf__lr': 0.0002, 'c...</td>\n",
       "      <td>47.736985</td>\n",
       "      <td>0.875137</td>\n",
       "      <td>0.012955</td>\n",
       "      <td>0.662380</td>\n",
       "      <td>0.014817</td>\n",
       "      <td>0.281786</td>\n",
       "      <td>0.012672</td>\n",
       "      <td>0.0002/256/40/0.2/1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>158</th>\n",
       "      <td>0.875909</td>\n",
       "      <td>0.011966</td>\n",
       "      <td>0.656419</td>\n",
       "      <td>0.014621</td>\n",
       "      <td>0.298571</td>\n",
       "      <td>0.015747</td>\n",
       "      <td>{'clf__batch_size': 256, 'clf__lr': 0.0002, 'c...</td>\n",
       "      <td>51.190706</td>\n",
       "      <td>0.873021</td>\n",
       "      <td>0.012727</td>\n",
       "      <td>0.661279</td>\n",
       "      <td>0.012646</td>\n",
       "      <td>0.280357</td>\n",
       "      <td>0.013791</td>\n",
       "      <td>0.0002/256/40/0.4/1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>159</th>\n",
       "      <td>0.873005</td>\n",
       "      <td>0.012953</td>\n",
       "      <td>0.658525</td>\n",
       "      <td>0.008867</td>\n",
       "      <td>0.298571</td>\n",
       "      <td>0.012413</td>\n",
       "      <td>{'clf__batch_size': 256, 'clf__lr': 0.0002, 'c...</td>\n",
       "      <td>90.862400</td>\n",
       "      <td>0.874278</td>\n",
       "      <td>0.015393</td>\n",
       "      <td>0.664633</td>\n",
       "      <td>0.013156</td>\n",
       "      <td>0.282857</td>\n",
       "      <td>0.013590</td>\n",
       "      <td>0.0002/256/40/0/2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>160</th>\n",
       "      <td>0.874304</td>\n",
       "      <td>0.012408</td>\n",
       "      <td>0.651828</td>\n",
       "      <td>0.012105</td>\n",
       "      <td>0.301071</td>\n",
       "      <td>0.012180</td>\n",
       "      <td>{'clf__batch_size': 256, 'clf__lr': 0.0002, 'c...</td>\n",
       "      <td>95.236988</td>\n",
       "      <td>0.871266</td>\n",
       "      <td>0.014046</td>\n",
       "      <td>0.648158</td>\n",
       "      <td>0.013471</td>\n",
       "      <td>0.283214</td>\n",
       "      <td>0.013938</td>\n",
       "      <td>0.0002/256/40/0.2/2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>161</th>\n",
       "      <td>0.869762</td>\n",
       "      <td>0.009537</td>\n",
       "      <td>0.641332</td>\n",
       "      <td>0.012711</td>\n",
       "      <td>0.300000</td>\n",
       "      <td>0.012976</td>\n",
       "      <td>{'clf__batch_size': 256, 'clf__lr': 0.0002, 'c...</td>\n",
       "      <td>75.461642</td>\n",
       "      <td>0.868728</td>\n",
       "      <td>0.012928</td>\n",
       "      <td>0.626461</td>\n",
       "      <td>0.018155</td>\n",
       "      <td>0.280357</td>\n",
       "      <td>0.015629</td>\n",
       "      <td>0.0002/256/40/0.4/2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>162 rows × 15 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     AUC ROC Test  AUC ROC Test Std  Average precision Test  \\\n",
       "0        0.873863          0.012930                0.660331   \n",
       "1        0.877067          0.015960                0.664257   \n",
       "2        0.875579          0.010993                0.666796   \n",
       "3        0.869641          0.016830                0.665317   \n",
       "4        0.875821          0.012659                0.668085   \n",
       "..            ...               ...                     ...   \n",
       "157      0.875426          0.012132                0.658144   \n",
       "158      0.875909          0.011966                0.656419   \n",
       "159      0.873005          0.012953                0.658525   \n",
       "160      0.874304          0.012408                0.651828   \n",
       "161      0.869762          0.009537                0.641332   \n",
       "\n",
       "     Average precision Test Std  Card Precision@100 Test  \\\n",
       "0                      0.018567                 0.295714   \n",
       "1                      0.012613                 0.299286   \n",
       "2                      0.017888                 0.297500   \n",
       "3                      0.013019                 0.296071   \n",
       "4                      0.015381                 0.301071   \n",
       "..                          ...                      ...   \n",
       "157                    0.013130                 0.297500   \n",
       "158                    0.014621                 0.298571   \n",
       "159                    0.008867                 0.298571   \n",
       "160                    0.012105                 0.301071   \n",
       "161                    0.012711                 0.300000   \n",
       "\n",
       "     Card Precision@100 Test Std  \\\n",
       "0                       0.012247   \n",
       "1                       0.013344   \n",
       "2                       0.017420   \n",
       "3                       0.015563   \n",
       "4                       0.016732   \n",
       "..                           ...   \n",
       "157                     0.013529   \n",
       "158                     0.015747   \n",
       "159                     0.012413   \n",
       "160                     0.012180   \n",
       "161                     0.012976   \n",
       "\n",
       "                                            Parameters  Execution time  \\\n",
       "0    {'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...       19.616337   \n",
       "1    {'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...       21.360825   \n",
       "2    {'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...       21.311841   \n",
       "3    {'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...       37.053668   \n",
       "4    {'clf__batch_size': 64, 'clf__lr': 0.001, 'clf...       42.327613   \n",
       "..                                                 ...             ...   \n",
       "157  {'clf__batch_size': 256, 'clf__lr': 0.0002, 'c...       47.736985   \n",
       "158  {'clf__batch_size': 256, 'clf__lr': 0.0002, 'c...       51.190706   \n",
       "159  {'clf__batch_size': 256, 'clf__lr': 0.0002, 'c...       90.862400   \n",
       "160  {'clf__batch_size': 256, 'clf__lr': 0.0002, 'c...       95.236988   \n",
       "161  {'clf__batch_size': 256, 'clf__lr': 0.0002, 'c...       75.461642   \n",
       "\n",
       "     AUC ROC Validation  AUC ROC Validation Std  Average precision Validation  \\\n",
       "0              0.878319                0.008551                      0.681225   \n",
       "1              0.877727                0.009484                      0.680278   \n",
       "2              0.875632                0.012137                      0.673602   \n",
       "3              0.874913                0.008695                      0.671733   \n",
       "4              0.880785                0.014945                      0.671497   \n",
       "..                  ...                     ...                           ...   \n",
       "157            0.875137                0.012955                      0.662380   \n",
       "158            0.873021                0.012727                      0.661279   \n",
       "159            0.874278                0.015393                      0.664633   \n",
       "160            0.871266                0.014046                      0.648158   \n",
       "161            0.868728                0.012928                      0.626461   \n",
       "\n",
       "     Average precision Validation Std  Card Precision@100 Validation  \\\n",
       "0                            0.010486                       0.282500   \n",
       "1                            0.014400                       0.283571   \n",
       "2                            0.010394                       0.278571   \n",
       "3                            0.007931                       0.281429   \n",
       "4                            0.012921                       0.282500   \n",
       "..                                ...                            ...   \n",
       "157                          0.014817                       0.281786   \n",
       "158                          0.012646                       0.280357   \n",
       "159                          0.013156                       0.282857   \n",
       "160                          0.013471                       0.283214   \n",
       "161                          0.018155                       0.280357   \n",
       "\n",
       "     Card Precision@100 Validation Std   Parameters summary  \n",
       "0                             0.017332      0.001/64/10/0/1  \n",
       "1                             0.013942    0.001/64/10/0.2/1  \n",
       "2                             0.014033    0.001/64/10/0.4/1  \n",
       "3                             0.012897      0.001/64/10/0/2  \n",
       "4                             0.015365    0.001/64/10/0.2/2  \n",
       "..                                 ...                  ...  \n",
       "157                           0.012672  0.0002/256/40/0.2/1  \n",
       "158                           0.013791  0.0002/256/40/0.4/1  \n",
       "159                           0.013590    0.0002/256/40/0/2  \n",
       "160                           0.013938  0.0002/256/40/0.2/2  \n",
       "161                           0.015629  0.0002/256/40/0.4/2  \n",
       "\n",
       "[162 rows x 15 columns]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "performances_df_nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7350.9550194740295"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "execution_time_nn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the number of parameters to tune is large here, and the training (with 20-40 epochs) is rather slow, the execution of the grid-search can take a long time (7350 seconds here). Indeed, it requires training 162 neural networks for each train/valid split of the prequential validation. To speed up the process, it would be beneficial to adopt the random search as suggested at the end of Section 5.3 or to use a hyperparameter tuning method more adapted to neural networks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>AUC ROC</th>\n",
       "      <th>Average precision</th>\n",
       "      <th>Card Precision@100</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Best estimated parameters</th>\n",
       "      <td>0.001/256/40/0.4/1</td>\n",
       "      <td>0.001/64/40/0.4/1</td>\n",
       "      <td>0.0002/64/40/0.2/2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Validation performance</th>\n",
       "      <td>0.881+/-0.01</td>\n",
       "      <td>0.701+/-0.01</td>\n",
       "      <td>0.288+/-0.01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Test performance</th>\n",
       "      <td>0.876+/-0.01</td>\n",
       "      <td>0.675+/-0.01</td>\n",
       "      <td>0.303+/-0.02</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Optimal parameter(s)</th>\n",
       "      <td>0.0002/64/40/0.2/2</td>\n",
       "      <td>0.001/128/40/0.4/1</td>\n",
       "      <td>0.001/256/20/0.4/2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Optimal test performance</th>\n",
       "      <td>0.878+/-0.01</td>\n",
       "      <td>0.683+/-0.01</td>\n",
       "      <td>0.304+/-0.02</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                      AUC ROC   Average precision  \\\n",
       "Best estimated parameters  0.001/256/40/0.4/1   0.001/64/40/0.4/1   \n",
       "Validation performance           0.881+/-0.01        0.701+/-0.01   \n",
       "Test performance                 0.876+/-0.01        0.675+/-0.01   \n",
       "Optimal parameter(s)       0.0002/64/40/0.2/2  0.001/128/40/0.4/1   \n",
       "Optimal test performance         0.878+/-0.01        0.683+/-0.01   \n",
       "\n",
       "                           Card Precision@100  \n",
       "Best estimated parameters  0.0002/64/40/0.2/2  \n",
       "Validation performance           0.288+/-0.01  \n",
       "Test performance                 0.303+/-0.02  \n",
       "Optimal parameter(s)       0.001/256/20/0.4/2  \n",
       "Optimal test performance         0.304+/-0.02  "
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summary_performances_nn=get_summary_performances(performances_df_nn, parameter_column_name=\"Parameters summary\")\n",
    "summary_performances_nn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optimal sets of hyperparameters strongly depend on the metric. The majority slightly favors the largest learning rate `0.001` and 2 hidden layers. Let us consider these values and visualize the impact of the others (batch size, number of epochs, and dropout)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "parameters_dict=dict(performances_df_nn['Parameters'])\n",
    "performances_df_nn['Parameters summary']=[\n",
    "                                   str(parameters_dict[i]['clf__batch_size'])+\n",
    "                                   '/'+\n",
    "                                   str(parameters_dict[i]['clf__max_epochs'])+\n",
    "                                   '/'+\n",
    "                                   str(parameters_dict[i]['clf__module__p'])\n",
    "    \n",
    "                                   for i in range(len(parameters_dict))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x288 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "performances_df_nn_subset = performances_df_nn[performances_df_nn['Parameters'].apply(lambda x:x['clf__lr']== 0.001 and x['clf__module__hidden_size']==500 and x['clf__module__num_layers']==2 and x['clf__module__p']==0.2 and x['clf__max_epochs']==20).values]\n",
    "summary_performances_nn_subset=get_summary_performances(performances_df_nn_subset, parameter_column_name=\"Parameters summary\")\n",
    "indexes_summary = summary_performances_nn_subset.index.values\n",
    "indexes_summary[0] = 'Best estimated parameters'\n",
    "summary_performances_nn_subset.rename(index = dict(zip(np.arange(len(indexes_summary)),indexes_summary)))\n",
    "get_performances_plots(performances_df_nn_subset, \n",
    "                       performance_metrics_list=['AUC ROC', 'Average precision', 'Card Precision@100'], \n",
    "                       expe_type_list=['Test','Validation'], expe_type_color_list=['#008000','#FF0000'],\n",
    "                       parameter_name=\"batch size\",\n",
    "                       summary_performances=summary_performances_nn_subset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, if we fix the number of epochs to 20, the dropout level to 0.2, the lower batch size leads to better results for average precision and card precision on the test set, whereas there is a sweet spot according to AUC-ROC. In fact, the optimal batch size is strongly connected to other optimizer parameters. Often, a larger batch size requires a larger number of epochs. To verify that, let us visualize the same plots but with the number of epochs to 40."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+MAAAEoCAYAAAAzNCCOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAACroUlEQVR4nOzdd3wUZf7A8c/MllRIA5KIFBUUpAuiHu2kqIAoCKgHdhAb/vAUERBBUex4oigcguCJigoeCkE9xVMsWDhQVGygoaiEkgDJZuvM8/tjs0OWtA0k2YR83754ZWfmmdnvruRhvvM0TSmlEEIIIYQQQgghRI3Rox2AEEIIIYQQQghR30gyLoQQQgghhBBC1DBJxoUQQgghhBBCiBomybgQQgghhBBCCFHDJBkXQgghhBBCCCFqmCTjQgghhBBCCCFEDZNkXAghhDgOnHbaabzzzjsRlZ08eTI33HBDNUckhDgaF154IU8//XS0wyjhjTfeoEuXLhGXr0ydJER9pck64/XT999/z4gRI+jUqRPLli0LO7Zr1y769evH8uXL6dChQ9ixK6+8ktatWzN9+nRr3w8//MA///lPvvrqKw4ePEhmZiZdu3bl2muv5bTTTiv1/SdPnsy///1vAGw2G02aNKFPnz7cfvvtJCUlhZX95ptvmDdvHhs3bqSwsJATTzyRCy+8kOuvv56YmJiwskcTixCi+pRX14iqtXfvXpKSknA6nRWWzc/PRylFw4YNayAyIeq2ffv2MX/+fD788EN2795NSkoKp512GldeeSV9+vSp8ve78MILOf/887n11ltLPf7GG28wZcoUa7tx48Z07dqViRMn0qxZsyqPJ8Tj8eByuUhLS4uofGXqpMry+/28+eabvP322/zyyy/4/X6aNm3Kueeey5VXXlmibvvqq69YtGgR33//PXv27OGhhx7ikksuCSujlGLu3Lm8+uqrHDp0iE6dOjF9+nRat25tlTl48CAPPPAAH3zwAQB9+/blnnvukbpUHDVpGa+nXn/9dUaNGsUvv/zCtm3bjvo6//3vfxk5ciSFhYU8+uijvP322zzxxBM0btyY2bNnl3vuX/7yFz755BM++OADHnjgAf773/9y3333hZVZu3Yto0ePJiUlhcWLF/Puu+8yfvx4Xn31Va677jp8Pl+VxCKEqB5VVddEyu/3V/t7VLXi9dixaNy4ccQ3vQ0aNJCbRyEisGvXLoYNG8Ynn3zC7bffzltvvcWSJUv461//yowZM476uqZpYhjGUZ8fFxfHJ598wscff8zjjz/Ojz/+yM0331zmNauiboyNjY04EYfK1UmVsWvXLkaMGMGSJUs499xzeeKJJ1iyZAk33HADP/30EwMHDmTTpk1h5xQWFnLqqady9913ExsbW+p1n3vuOZ5//nnuueceli9fTmpqKtdeey0FBQVWmTvuuIMtW7awcOFCFi5cyJYtW5g0aVKVf0ZRjyhR77jdbtW1a1f1448/qilTpqiHH3447PjOnTvVqaeeqjZv3lzi3CuuuELdd999SimlCgsL1VlnnaVuuOGGUt/n4MGDZcZw1113qXHjxoXte+ihh1T37t2t7dD1b7rpphLnf/fdd+q0005Tzz333DHHIoSoHuXVNbfffrsaP358WHnDMFTv3r3V888/r5RSyjRNtWDBAtWvXz/VoUMHdeGFF6qVK1da5UN11apVq9SVV16pOnTooF588UWVm5ur/v73v6tevXqpDh06qEGDBqnly5eHvZfL5VJ33nmn6ty5szrnnHPU/Pnz1bhx49Rdd91llfF6verRRx9VvXr1Uh07dlSXXHKJWrduXbmf+YorrlD33HOPuv/++1W3bt1Ut27d1MMPP6wMw7DKnHvuueqpp55SkydPVl27dlW33nqrUkqp//3vf2r06NGqY8eOqmfPnmr69OkqPz/fOs80TbVo0SI1YMAA1a5dO9WrVy/1+OOPW8dPPfVU9fbbb1vbTz/9tPrrX/+q2rVrp/7yl7+oO++80zp2ZB3s9XrVAw88oM455xzVvn17NXLkSPXVV19Zxz///HN16qmnqs8++0yNGDFCdezYUQ0bNkx999135X4fQtR1Y8eOVT179lQFBQUljhW/t3j++efVhRdeqDp16qR69uyppk6dGnZ8xYoVqnPnzurDDz9UgwcPVm3btlU//fST2rdvn7rxxhtVhw4d1F//+lf1+uuvq8GDB6unnnqqzJhC1yruzTffVKeeeqratm2b9fv64YcfquHDh6t27dqpDz74oMI6VSmldu/erW6//XbVvXt31bFjR3XRRRep9evXl/q+f/zxh7rxxhvVmWeeqTp27KjOP/98tXr1auv4kXXSjz/+qK6++mrVoUMHdeaZZ6q77rpLHTp0yDoeqpeWLFmievbsqbp166YmT56sCgsLrTL5+fnqvPPOU7Nnz1amaZb6/bz//vvqL3/5i8rJySn1eOfOndWKFSvC9pmmqXr06KGeffZZa5/b7VadO3dWr7zyilJKqa1bt6pTTz1VbdiwwSrz1VdfWd+7EEdDWsbroXfeeYcTTjiB0047jYsvvpiVK1ce1RPTTz75hLy8PMaNG1fq8cq0uuzcuZOPP/4Yu91e4vpjx44tUb5du3acc845rF69uspjEUJUjfLqmosuuogPP/yQ/Px8q/yXX37J3r17GTx4MABPPvkky5cvZ/r06WRlZTFu3DhmzJjBhx9+GPY+TzzxBKNGjSIrK4v+/fvj8/k4/fTT+ec//0lWVhZXXXUVM2bMYP369dY5Dz/8MF999RVz587lhRde4Mcff2TDhg1h150yZQpfffUVs2fPZvXq1QwbNoybbrqJH3/8sdzPvWrVKpRSLFu2jPvuu4/XXnuNF154IazM4sWLOfnkk1mxYgW33347P/30E2PGjKFv3768+eabzJ07lx9//JGpU6eGfc5nn32WcePGkZWVxZw5c8jIyCg1hnfffZfnn3+eGTNm8J///If58+fTsWPHMmMO9SZ68MEHWblyJaeeeirXX389e/bsCSs3e/Zs7rjjDt544w1SUlKYOHEiSka7iePUgQMH+Pjjjxk9ejQJCQkljhe/t9A0jalTp7J69Wpmz57N5s2buf/++8PKe71enn32We677z6ysrI44YQTmDx5Mjt27GDx4sU888wzvPnmm/z++++VjjXU2hsIBKx9jz/+OLfddhtvv/02nTp1qrBOLSws5Morr+T333/nmWeeYdWqVdxyyy1lvud9992Hx+PhX//6F6tXr2bq1Kk0aNCg1LKFhYWMGTOG+Ph4Xn/9debOncumTZvC6jiADRs28Msvv7BkyRL+8Y9/8N577/Gvf/3LOr5w4ULatm3L7bffjsvlYvLkyfTs2ZNhw4bxxhtvMHjwYPr168fIkSN59tlnI/7+du3axd69e+nRo0fYd3rmmWdareybNm0iPj6eM844wyrTtWtX4uPjS7TECxEpe8VFxPFmxYoVXHzxxQB0796duLg41q5dywUXXFCp62RnZwNwyimnHFUcH3/8MV26dMEwDLxeL0DYGKjffvut3OufcsopvP7661USixCi6pVX1/To0YMGDRrwzjvvMHLkSCCYxJ599tk0adKEwsJCFi9ezPPPP0+3bt0AaNasGZs3b+all17ir3/9q/U+V1xxRYn6q/hDvMsuu4zPP/+c1atXc8455+ByuXjjjTd45JFHrBuvWbNmhY393LFjB1lZWXzwwQeccMIJ1vt89tlnLFu2jHvvvbfMz92kSROmTZuGpmmccsopZGdns3jxYq699lqrTPfu3bn++uut7UmTJjFw4ECuu+46a9+9997L0KFD2b9/P7GxsSxZsoSpU6cyYsQIAFq0aFHmZEp//PEHjRs3pkePHjgcDk444YQSc4CEFBYWsmzZMh544AHre73vvvv4/PPPeemll/j73/9ulZ0wYQJnn302ADfffDOjRo0iJyenzIcCQtRlO3bsQCkV0b3FNddcY70+8cQTufPOO7n55pt55JFH0PVg25dhGNxzzz20b98eCN7nrFu3jpdffpmuXbsCwQeF/fv3r1Scu3fvZtGiRWRkZNCyZUvy8vIAGD9+PD179gSIqE5dvXo1e/fuZdmyZaSmpgLQvHnzMt/3999/5/zzz6dNmzbW9cqyevVq3G43jz76KImJiQDMnDmTq666iu3bt9OiRQsAEhMTue+++7DZbJxyyilccMEFrF+/3ppwcuXKlSxYsMD6rrZt28ZTTz2Fx+Phvvvusx74XnLJJYwaNarcurq4vXv3AtCoUaOw/WlpadZDyX379pGamoqmadZxTdNITU1l3759Eb2PEEeSZLye2b59O//73/94/PHHgWAlMmTIEJYvX17pZPxYW0O6devG/fffj8fj4fXXX2fHjh1ceeWVR3UtaZkRonapqK6x2+0MGjSIVatWMXLkSHw+H//5z3+4++67Adi6dSter5exY8eG3fiEJukpLnRjG2IYBgsWLGDNmjXs2bMHn8+H3++ne/fuQLAnjt/vD2spjo+PD5uk5/vvv0cpZbXSh/h8PisZLUunTp3CYu7SpQtz5syhoKDAugk9Mubvv/+e7du38/bbb1v7QvXajh07sNls+Hw+zjnnnHLfO+SCCy7gX//6F/369aNnz5706tWLfv36lTp+c8eOHfj9/rDWHpvNRufOnUuM8y8+EWaTJk0A2L9/vyTj4rhUmXuL9evXs2DBArZt20Z+fj6maeL3+9m7dy/p6ekA2O122rZta52zbds2dF0Pq4uaNm1q/W6Vp7CwkC5duqCUwu12065dO55++umw3/Hi9UwkdeqWLVs47bTTrES8IldddRX33nsvH3/8MWeffTYDBgwoUbcV/6ynnXaaVQdCsG7UdZ2tW7dayXirVq2w2WxWmSZNmvDNN98AwcnT8vPzOfXUU4HgvEJz58616q6bb76ZOXPmAMHx6gcOHIjocwgRTZKM1zOvv/46hmFw7rnnWvtC/9j8+eefZGZmWhVl8QkrQg4dOmR1QTrppJOAYAVb/CYuUnFxcVblO23aNK688kqeffZZa/bQ0PW3bt1qPTEubtu2bbRs2bJKYhFCVK1I6pqLLrqIyy67jJycHL755hv8fj8DBgwIKztv3jyrZTqk+HAWCNYlxS1atIjFixczdepUTjvtNOLj43niiSfIzc2NOH6lFJqmsXz58hLvV9bkP5VxZMymaTJy5Miw1rWQ9PR0fv7550pdPzMzk3feeYf169fz2Wef8cgjj/DMM8/w2muvER8fH/F1it+0Q/h3HzpmmmalYhOirmjRogWaprFt2zarbirN77//zg033MCll17K//3f/5GcnMyWLVu4/fbbw4YBOp3OsEQz5Mjfs0jExcWxcuVKdF0nLS2t1N/r4vVMZerUSI0cOZJevXrx0Ucf8dlnn3H55Zdzww03lDkLfFmKf/4jY9E0zYo9EAiEPWzw+/1hn7v4UILvv//euseMROPGjYFg63fx72f//v1Wa3mjRo3Izc21/n2A4Peam5tbokVdiEjJmPF6JBAIsHLlSu644w5Wrlxp/XnzzTc57bTTWLFiBQDJycmkpKTw3XffhZ1fUFDAjh07rMS3R48epKSkWN2FjnTo0KFKxTd+/Hiee+45cnJyrOsnJyezaNGiEmW///571q9fz5AhQ6olFiHE0Yu0runYsSPNmzdn9erVrFq1in79+lk3U6eccgpOp5M//viDFi1ahP05smX8SBs3buTcc89l6NChtG3blubNm1tDWSDYldLhcPDtt99a+9xuN7/88ou13bZtW5RS7N27t8T7h1q5yvLNN9+Etah9/fXXNGnSJKxF6Einn3661Tp05J/Y2FhOPvlknE5n2Lj3isTExPDXv/6VqVOnsnz5cn755Rc2btxYolzz5s1xOBxhxwzD4Ouvv5ahP6JeS05OpmfPnixduhSXy1XieOje4rvvvsPv9zNlyhS6dOnCSSedVGK+hdKcfPLJmKbJ5s2brX1//PFHROdqmkaLFi1o1qxZRA/YIqlTTz/9dH766adKPbjMyMjgsssuY86cOfzf//0fr776apnv//PPP4c19GzatAnTNCOuZ1JSUggEAtb3061bNxYsWEBhYSF5eXnW3By//PIL9913H2PGjIn4c5x44ok0btyYzz77zNrn9XrZsGGDNRyoS5cuFBYWho0P37Rpk9VLQYijIcl4PfLhhx+Sl5fHyJEjOfXUU8P+DBo0iDfeeMO6gbz22mt57rnnePPNN9mxYwebN29m4sSJpKSkWN3Z4+PjeeCBB/jkk08YN24cn376Kbt27eL777/nySefZOLEiZWK76yzzqJVq1bMmzcv7PofffQRU6ZMYcuWLfzxxx9kZWVx00030bVrV6666qpqiUUIcfQqU9cMGTKE119/nQ8//JCLLrrIukZiYiLXXXcdjz76KMuXL2f79u388MMPvPLKK2Xe7IW0bNmS9evXs2HDBrZt28bMmTPZtWuXdTwhIYFLLrmExx9/nPXr17N161amTZuGaZpWa8dJJ53EkCFDmDJlCu+88w47d+7k22+/ZdGiRfznP/8p9/337NnDrFmz+PXXX3nnnXdYtGhRqS3exV1//fVs3ryZ6dOns2XLFrZv385///tfpk+fbn0fV111FU888QQrVqyw6uWXX3651Ou98cYbvP766/z000/s3LmTN954A4fDUWpLUXx8PH/72994/PHH+eijj9i2bRv33nsv+/fvZ9SoUeXGLcTxLrR82fDhw3n77bf59ddf2bZtGy+//LJVZ7Vo0QLTNHnhhRfYuXMnq1evLjFpY2lOPvlkevXqxYwZM9i0aRM//PADkydPrpLeN0eKpE698MILSUtL4+abb2bDhg3s3LmTtWvX8vnnn5d6zQceeIB169axc+dOfvjhBz7++GNatWpVatkhQ4YQGxvLXXfdxU8//cRXX33F9OnTOe+88yJuwdZ1nX79+vHSSy8BcPfdd7Nt2za6du1K3759OeOMM/j9998ZO3YsV1xxRdg64i6Xix9++IEffvgB0zT5448/+OGHH/jjjz+A4MONq666iueee47//Oc//Pzzz0yePJn4+HguvPBCIPhAofj/r02bNjFjxgzOPfdcTj755Mj+RwhxBOmmXo8sX76cs846i5SUlBLHBg4cyOzZs/n000/p2bMnY8eOJT4+noULF7Jr1y4aNGhA165d+de//hX2j0T//v1ZtmwZCxYs4M477+TQoUNkZGTQrVs37rzzzkrHeO211zJlyhSuv/56mjZtyoABA1i6dCnz58/n6quvxu1207RpU0aOHMm4cePCuitVdSxCiKNTmbrm4osv5umnnyYtLS1sFluA2267jUaNGvH8889z7733kpiYSNu2bUtdYaG4m266iV27dnH99dcTGxvLsGHDGDJkSNj457vuugu3281NN91EfHw811xzDfv27QurUx566CHmz5/PY489Rk5ODklJSXTo0IGzzjqr3PcfMmQIpmly6aWXomkaI0aMqDAZb9OmDUuXLuXJJ5/kiiuuwDRNmjVrFjaR0x133EFSUhLPPvssOTk5pKWlMXTo0FKv17BhQ5577jkeeeQRAoEAp5xyCk8//XSZEyyF6sgpU6Zw6NAhTj/9dJ577rmIxq4KcTxr1qwZb7zxBv/85z95/PHHycnJITk5mTZt2jBz5kwg+Pt7991389xzz/Hkk0/SpUsXJk2aFDb5YVkefvhhpk2bxtVXX01KSgrjx4+vVMt0ZVRUp8bHx7N06VIefvhhbrzxRvx+PyeddFLY5LrFKaV44IEH+PPPP0lISOCcc85h8uTJpZaNi4tj0aJFPPjgg4wcOZKYmBj69etnzRMSqVtuuYURI0bQoUMH+vfvz1tvvcW+fftITEzEbrdz5ZVXltpl/LvvvrMacACefvppnn76aYYNG8bDDz8MBB+Ker1eZs6cycGDB+nUqRPPP/98WK+m2bNnc//991ut7n379rUemgpxNDQlM18JIYSo53w+H+eeey5jxowJm9G8sq688kpat24tN2dCCFFNPv/8cyZMmMD555/P3/72N0499VR0Xee3337jpZdeYt++fdZEbkLUdtIyLoQQot7ZsmUL27Zto2PHjrhcLp577jlcLheDBg2KdmhCCCHKcfbZZ7Ny5UqeffZZrrnmGg4dOoSu6yQmJnLhhRdyzz33RDtEISImybgQQoh6afHixfz222/Y7Xarm7gs0SWEELVfZmYm999/P/fddx+5ubkYhkHjxo2tNd2FqCukm7oQQgghhBBCCFHD5PGREEIIIYQQQghRwyQZF0IIIYQQQgghapgk40IIIYQQQgghRA2TZFwIIYQQQgghhKhhkowLIYQQQgghhBA1TJJxIYQQQgghhBCihkkyLoQQQgghhBBC1DBJxoUQQgghhBBCiBomybgQQgghhBBCCFHDJBkXQgghhBBCCCFqmCTjQgghhBBCCCFEDZNkXAghhBBCCCGEqGGSjAshhBBCCCGEEDVMknEhhBBCCCGEEKKGSTIuhBBCCCGEEELUMEnGhRBCCCGEEEKIGibJuBBCCCGEEEIIUcMkGRdCCCGEEEIIIWqYPdoBVBXDMDAMo8JyNpstonKi6sl3Hz2RfvdOp7MGohFHS+q52k++++iJ5LuXOq72k3qu9pPvPnqknjv+HFfJ+P79+yssl5aWFlE5UfXku4+eSL/7zMzMGohGHC2p52o/+e6jJ5LvXuq42k/qudpPvvvokXru+CPd1IUQQgghhBBCiBomybgQQgghhBBCCFHDJBkXQgghhBBCCCFq2HEzZlwIIYQQQgghxNHz+/3s2LEDj8cT7VCOC7GxsTRv3hyHw1HqcUnGhRBCCCGEEEKwY8cObDYbTZo0QdO0aIdTpymlcLlc7Nixg1NOOaXUMtJNXQghhBBCCCEEHo+HhIQEScSrgKZpJCQklNvLQJJxIYQQQgghhBAAkohXoYq+S+mmLoQQQgghhBCi2hw8eJD/+7//AyA3Nxdd10lOTgZg4cKFZY6prm6vvvoqF198MbGxsVF5f0nGRb2jlDr8GlXq/hLHyigXyf4S26r0/UeeX3zbxDz82jRL3Y86fL3i5ysUgdgANmWTJ51C1LQj6pVS90VSpirPi3BfqbVFpHEdua9YvVXmvtLOK+36ZV1LKZA6TogqZZgGARXAUAYBI4DP9OE95CXXlWuV0Yr+qwxNq9w5VtlKvE3onEq9j6ZV+l7paD6/9V6VPC8hkFDp96ktkpKSeOGFFwBYtGgRcXFxjBo1KspRwWuvvcb5558vybg4PpjKDP+DiVIKwzSgEHLducFEMZSElpFAQoQJKMXOV4rDl1Vhia6pzLDyocqv+OvyKKWsyrm888vaf2RyHkksYa/L+IfhyNiLlyt+7KD7ICmkHNU/FqJ869atY9asWZimyciRIxk3blzY8QcffJAvvvgCCI7D2r9/Pxs2bABgzJgxfPPNN3Tt2pV//vOfNR67qAJ+P5rfDx4PWmEh5OZiy8ur3DVKSyLL2KeK74vwPA3C95V1XiRxRaqU81Qk1yqtTCT7lIJDhyApKcIAhRAQvL8JqACGaWAoA7/pxxvw4jN9+A1/2P2Lhoau6cSYMQSMQJn3NuW+31GcE4qzpt6rUu9RQ3GF7pFtCTbiiKv0+bWR1+tlxIgRLFu2DLvdjsvl4uqrr2bZsmXcdttttGrVik2bNmEYBlOnTuX000/H7Xbzj3/8g19//ZVAIMCYMWPo1atX2HX37dvH9OnTcblcGIbBxIkT6dy5M1988QWLFi3C7/fTtGlTpk6dSlZWFvv27ePWW28lKSmJuXPn1vj3IMm4KFN5iXXALHpKqgIEzACmaRJQgbDzNTSrwtHQMGNNDvoOWttWuTISyBKJo1b6fj009YEGml65ZLbe0KAG/k2qdwzDYObMmSxevJj09HRGjBhB3759adWqlVVm6tSp1usXX3yRLVu2WNtjx47F7Xbz6quv1mjc4igZBvh8weS7sBDd7bZaaZWug90O8fEony/KgYarF7/6pbWWCyEArEQ7oAIYhoHX9OI3/fgCPgIqgFIKXdNRBH/aNBu6phNnjyv1/slpc+KwRadLcX3mN/3RDqFKxcTE0KVLFz777DN69+7N+++/T58+fbDbg+mpx+PhhRde4Ouvv+bBBx9k6dKlvPDCC3Tt2pWpU6eSn5/P9ddfT7du3YiLO/yA4r333uOss87i6quvxjAMPB4PBw4c4IUXXmDOnDnExcWxdOlSli1bxnXXXceyZct4+umnrS7zNU2S8XpAqWArcVUm1poWfDqqo6NpGg6bgxgtptw44hxxeOyyZqE4fmzevJkWLVrQrFkzAAYPHszatWvDkvHisrKyuPXWW63tc845x2o1F7WMUsHEOxAAtxvN5Qom4boebKF2OFAxMcHt4ur7gz8hRI1TSgXv48wApjKtVm2P4bHu8TS04JM5DWyaDZtmi+jeTYjqNGTIEF566SV69+5NVlYWkydPto4NGDAAgM6dO1NYWEh+fj5ffvkln3zyCS+//DIAPp+PnJwcWrZsaZ3Xtm1bHnzwQQKBAL169eLUU0/l008/JTs7mxtvvBGAQCBA+/bta+6DlkOS8TpGqWBSrQhWvKYyrX2mMvGbfgxlHK6UqymxFkJATk4OGRkZ1nZ6ejqbN28utezvv//Orl27OPvss2sqPFEZR3Q317ze4H2rUii7HULJtxBCRIGpTCuxNkwDn+GzWrj9RniLqYaGTQ8m3LG2WOkdKGqtjh07Mnv2bDZu3Ihpmpx88slllg39PZ41axYtWrQos1znzp155plnWL9+PbNmzeLyyy+nQYMGnHnmmdx3331V/hmOlSTjUWQl0RxusQ7tC7VSWy3XGFY3Iw2t1DHMklgLUXtlZWVx/vnnY7PZjvoaNpuNtLS0CsvZ7faIytVbRd3N8fnA5YLCwsPdnHUdkpODXc6P4gbWbreTkpJStfGKipkmdtOUv/eizgq1boeS7YAZwGt48Rk+fKbPaojRCe9ObtNsOB3OaIcvxFG74IILuPfee7n22mvD9q9du5auXbvyzTffkJCQQGJiIt27d2f58uXcfvvtaJrGzz//zKmnnhp23u7du2ncuDEXXXQRPp+Pn376iauvvponnniCXbt2ceKJJ+J2u9m7dy/NmzcnPj6ewsJC6aZe1x1NYh2qWEPdhkIt1qUl1rqmY7fZ0TVZGl6I2iI9PZ3du3db2zk5OaSnp5dads2aNUyfPv2Y3s8wDPbv319hubS0tIjK1QtHdjcvLAy2gGua1d0cuz28u7nXe9Rvl5KSQl5lJ3ATx840SUlIqPDvfWZmZg0FJERJpjLDupN7A8GWba/pJWAEMDGte8HQvZ9NtxFji5H7P3HcOu+881iwYAH9+/cP2+90OrnmmmsIBALW/DvXXnstc+bM4aqrrsI0TU444QQee+yxsPM2btzIyy+/jN1uJy4ujnvuuYeUlBTuvvtuZsyYgd8f7Ely/fXX07x5cy666CJuv/12GjVqdPxN4FbRLMO///47U6dOJTc3l+TkZB577DGry+e///1v5s2bB8BNN93EsGHDqjPUMEebWBdXvCu4runWDJSapmEjOE5Hug0JUbd16NCB7Oxsdu7cSXp6OllZWcyePbtEuW3btnHo0CG6dOkShSjrGb8/2OXc6w2O8y6tu7lTWpGEENWj1KXAAl4CZgC/8odNLhvJZGlCHI/GjBljvd68eTPnnnsuDRo0CCtz/vnnc9ttt4Xti4mJYdKkSeVee9CgQQwaNKjE/q5du7Jo0aIS+0eOHMnIkSMrEX3VqrZkPJJZhh955BGGDh3KsGHDWL9+PbNnz+axxx7jwIEDzJ07lxUrVqBpGpdccgl9+/YlqQqWLHH73RT6CyWxrkmGgebzoWk6en4+aDroOkoj2Dql6aBpKF0r2tZKTookRC1kt9uZPn06Y8eOxTAMhg8fTuvWrZkzZw7t27enX79+QLBVfNCgQSXqiVGjRvHrr79SWFhI7969mTVrVoklOkQ5IpjdXMXHB+uXKIcqhDg+RLIUWPGlSmWyNCHK9sQTT/D555/z+OOPRzuUqKm2ZDySWYa3bdvGlClTADj77LO55ZZbAPjkk0/o0aOH1Xe/R48efPzxx1x44YXHFFPADLDz4E4OuA4AklhXm0AAze9Hd3vQCwvR/cFlM2zJydgPHqL4QjuaUsGkvOgfLY3Qmo0a6BrKVpS46zrY7MGyNhvKZgNdA90WnshTSlIv/z9FNerTpw99+vQJ2zdhwoSw7eIzqBcXmg1URCCC7ualzm4ujmumMoMTWfndKM0r64yLKlF8KTDTNINjt01fmUuBhVq4pXVbiMq5/fbbS90fje7i0VJtyXgkswy3adOG//znP1x99dW89957uFwu8vLySj03JyenagLTIMGRUDXXEkGBALrPj+YJT76VzYayOzDig11CVXw8pr8SayQqFWzlUqAZJgS8aApQRfuUAkwgeDOuoaG0okQ+eIGivF8Duy2YpOs6SrcFf4Yl+raSrfNaUet9KKEP/RFCVD/pbi5KoZSyZpF2+Vz4zOCa7pqp0G0B5F93EYkjlwLzm/7g3ysjOIbb6iFptQ3o2DU7dt1OjC6t20KIqhPVCdwmTZrE/fffz7///W+6detGenr6Uc80HMkswwEzgOuQi8SUxKN6D1EkEEDz+tDcbrQCF1ogmHxrNjsqOSU4GVIpbHYbydFqtTDNouReEUzSFVpRoo9hQsAADrfZa0odTry1oon1lALdhtK0YPJuK0rwbUXJvd0ebK0v6oYfSt6tBL94Ul/DrXcew0NaUppMACNqJ8MIJt4+n3Q3F2GUUlaiVBgoxB1wA8HhY3bNTpw9PljOCJR3GVEPlbYUmM8M/gkYAWv4IRxeCkzXdFkKTAhRo6otGY9kluH09HSrG4LL5eI///kPDRs2JD09nS+//DLs3O7du5f7fpHMMhwwAwT0AHmHZKbbSgm1fLvdh1u+NQ2l68GZiEMPUAwDfGXPQpyclMSBgwdrKOhqogJhSb1WPME3i7Yr0w3fHmqRL9YN324PblfUDb94cl8BR4KD/fv3V5iMy0zDotpJd3NRgYAZnPTK5XPhNtxFdSbB5NsWJz2UhMWaLK1o7p/irduGCj5kt2Ynl6XAhBC1ULUl45HMMhyaRV3XdRYsWMDw4cMB6NmzJ0888QQHixK3Tz75pMwxBaIa+P3o/gBaYSG2QncwyYaibud2DGc97qJltWwHN49spatUq12Z3fDdRd3wTaw+coCmgmvKH74RjbAbvk1HJw7iZe1jEQXS3VxUIGAG8Jv+4ASrgUICZiA4j4tmI0aPQZMePeIInoCHrblbyT2Ua+0LzQFk0204bU7pCSaEqBOqLRmPZJbhL7/8kieeeAJN0+jWrRszZswAIDk5mZtvvpkRI0YAcMstt0RtIfZ6we+3Wr6t5LvoRtm02yGmHiff1SnU3R1QlByeEXFir1TYHy0QbL3XQtumwu46BCdlgk1uTkQ1ku7mIgKGaVjLPbkCLvym30qkHJoDp0P+zRHlCy07K3MACXH8OXjwIP/3f/8HBBtudV238sCFCxficDjKPX/jxo04HA46dOhQ3aFWCU2F+n/VcT6fL6Ju6gf1g/hdlZhE7HgUSr4LC7G5PRAIBG+Oi1q+Ocpx+xU5Lrqp11FO5SOxZSd0W/nP36Sbeu0WST0HkJaWFlG5YxJBd3Ps9nrX3TwlJYW8PBkKVZypTPyGP2zSNQ0NNHBoDmz6sbcLKCNAfIydhObl33xJHVf7RVLPFfoLcTvccj8XJVLPRYff9NMotRFx/rhyyx1rPff999+XGFocLYsWLSIuLo5Ro0ZV6znVLScnh3bt2pV6LKoTuImaofn8aP7Sk2/T4ZCWbyFExaS7uYhQaNI1r+Gl0F+Ix/AARZOu6YcnXRNCCCEi8eOPP/L000/jdrtJSkri7rvvplGjRrz++uusXLkSm81Gy5Ytuemmm1i5ciW6rvPuu+/y97//nc6dO0c7/HJJMn68UQrNHzicfLsKgy1YgLLZJfkWQlRMupuLSvIbfnymL9hiGXBjYgaXg0ImXRNCCHH0lFL84x//4OGHHyYlJYX333+fBQsWMHXqVF588UWWL1+O0+kkPz+fBg0aMHTo0FrXMl4eScbrulDy7fOhFwZnOw+NHVZ2B6bMSiyEKI/Mbi6OQmjStUJ/IYWBQmtdZptmI9YWK8m3EEIcB1798VVe/uHlKr3mqLajuKzNZRGX9/v9/Prrr9x2220AmKZpLWfdqlUr7rvvPnr37k2vXr2qNM6aIsl4XVNa8m2aoIGySfIthKhA8e7mhYVoHo90NxcVCk265gl4cPldBFRwXW+bZsOpO2XGcyGEENVCKcVJJ53EggULShx77LHH+Prrr/n000954YUX+Ne//hWFCI+NJOO1nVLBMd8+H7rbI8m3ECJy0t1cHCVTmdaazS5/0aRrSkPTNZyaE6dNhjvVJ+vWrWPWrFmYpsnIkSMZN25c2PFXXnmFl19+GV3XiY+P5/7776dVq1Z8+umnzJ49G7/fj8Ph4M477+Scc86J0qcQQlTWZW0uq1QrdnVwOp0cOHCA7777jvbt2xMIBNixYwctW7Zkz549dO3alU6dOvH+++/jdruJj4/H5XJFNebKkGS8timefIdavoMHgt3OY6X7nxCiHIYBe/ag//67dDcXESs+6ZrL58Jreq0Zz+2anXi7LCFVXxmGwcyZM1m8eDHp6emMGDGCvn370qpVK6vMkCFD+Nvf/gbA2rVreeihh1i0aBEpKSnMmzeP9PR0fv75Z8aMGcPHH38crY8ihKiDNE3jgQce4Mknn8TlchEIBLjsssto3rw5M2fOpKCgAKUUI0eOpEGDBvTo0YNp06bx8ccfywRuIgJW8u1Fd7mDLVfBA8HkO04mvhFCVILfD/n5oOuoBEmgROmUUgTMQHDG84AbT9GkaxoaDs0hk64Jy+bNm2nRogXNmjUDYPDgwaxduzYsGU9MTLReu91utKK/O6effrq1v3Xr1ni9Xnw+H04ZCiOEiMCYMWOs188++2yJ4/PmzSuxr3nz5nWqu7ok4zWttORbqWA3Ubtdkm8hxDExTIODvnxcSqEH/Ng0G7qmY9Ns1g2yqJ8CZsCa8Tw06ZqGhl2zy6Rrokw5OTlkZGRY2+np6WzevLlEuZdeeonFixfj9/t54YUXShx/9913Of300yURF0KIYiQZr26mGVxmzOeT5FsIUe0CZoB8917yTUCB0lSwuzHBybbsmh2HzYHD5sCu29E5nKhLwn58Cc147g64KfQXEjAD1v/nGD1GJl0TVWr06NGMHj2aVatWMW/ePB555BHr2C+//MLjjz/O888/X+F1bDabNVNyWWJ9seS4c0hMSSy3nKgedrudlJSUaIdR7/gNPza7jbSG5f9+iLpFkvGqVjz5LiiaMEkD0FAO6XYuhKh+Ns1GnL3kBFtKmRjKwB1w4wq4UCqYqKui6ds0tODa0GUk7Lqmo2u6JOy1VGjSNU/AQ2GgEL/pB8XhSdccMumaqLz09HR2795tbefk5JCenl5m+cGDB3Pvvfda27t372b8+PE88sgjNG/evML3MwyD/fv3l1um0F9IwBEgz5VX8QcQVS4lJYW8PPnua5rf9NMotVGFvx+ZmZk1FJGoCpKMH6tQ8u31orsK0d2e8OS7aKZiIcTxqaJZhh988EG++OILADweD/v372fDhg0A/Pvf/7bGO910000MGzasWmPVNB17Ba2hpmlgKpPCQCHKr1CUTNhtug2HHkzUHboDm24LS9htuq1aP4cIMpWJ3/DjNYOTrvlMHxCc7MahOYizx0c5QnE86NChA9nZ2ezcuZP09HSysrKYPXt2WJns7GxatmwJwIcffkiLFi0AOHToEOPGjeOOO+6ga9euNR26EELUepKMV1Yo+fZ40QuDybcGKE1HOeySfAtRj0Qyy/DUqVOt1y+++CJbtmwB4MCBA8ydO5cVK1agaRqXXHIJffv2JSkpqcY/R3G6bkPHhh1H6QWUwlQmASM4+ZdSkSXsVgu7friFXVROaMZzn+GjMFCIOxCc8FNDw67bJfkW1cJutzN9+nTGjh2LYRgMHz6c1q1bM2fOHNq3b0+/fv1YunQp69evx26307BhQ6uL+tKlS9mxYwfPPPMMzzzzDADPP/98hd3QhRCivpBkvCKmiebzoXl92FwuNI9Xkm8hBBDZLMPFZWVlceuttwLwySef0KNHD5KTkwHo0aMHH3/8MRdeeGGNxH7UNA1dq4KEXQtOHGbXHTh0O/aiP5KwhwtNuubyuXAbbpQKfn92zS4znosa06dPH/r06RO2b8KECdbradOmlXrezTffzM0331ytsQkhRF0mdzpHMk00jwf94CEcf/yJc/sOnH/kYM89gFJgJiRgJCRgxsehHA65ERKiHittluGcnJxSy/7+++/s2rWLs88+u9Ln1jmahq7bsNscxNhiibXHEWePt37G2eOJ1WPR0PAbPvL9+eR6cskpzGF34W525e9iZ/5OduTv4I+CP9hbuJcDngO4/C7cATc+w0fADGAqM9qftMoFzADugJtcdy678nexK38Xewv34jW8xOgx1vfnsDnl3x8hhBDHnfHjx1vD+0JeffVVHnvssTLL//DDDwDccccd5OfnlyizaNEiXn755XLfd926dfz222/W9nPPPcdXX31V2fArTVrGDQPN70f3eNFdrmAruAq2fJtOBype1ukVQhy7rKwszj//fGy2ox9PHcksw54YG3v22khuGN3u7lVBoTCUgaEMlKnwKV9wTg51uIxNs1kTzTn04KRzNt2GTbNZY9hrcsK5ys4ybJgGPtOH2+/G5XfhV35wgMPpIE1Pw6bJ+PtImGYA5fVK92chhKjjBgwYwPvvv89ZZ51l7Xv//fe55ZZbKjz3yPksKmPdunX06NGDk046CYDrr7/+qK9VGfUvGTeMYMv3Ecm3qdtQDrsk30KIiFVmluE1a9Ywffr0sHO//PLLsHO7d+9e7vtFMsuwt+Agpmlw4ODBSD5CnedTPgpUAaYyMQm2lIe6coeUtaRbqCt8VS7pVtEsw6VNuqahgQYOzYFND/6z7CdQJfHUF8oIEB9jl1mGhRCijjv33HNZsGABfr8fh8PBn3/+yf79+3nvvfd46qmn8Hq9nHvuuYwdO7bEucOHD2fRokUkJyfzwgsv8Pbbb5OSkkKTJk047bTTAHjrrbd48803CQQCNG3alOnTp/PLL7/wySef8PXXX7NkyRJmzZrFkiVL6NGjB+eeey4bNmxg7ty5GIZB27ZtmThxIk6nk+HDhzNw4EA+/fRTAoEADzzwgDWBZaTqVzJuGDh+/x093yvJtxDimEUyyzDAtm3bOHToEF26dLH29ezZkyeeeIKDRUnzJ598wu23315jsR8vIpkhvrwl3UJj2ctbg/1YlnQLTbrmNbwU+gvxGJ5g3DLpmhBCCFFCw4YNOf300/n888/p1asX77//Pn379uWqq66iYcOGGIbBhAkT2Lp1a5lz9Pz444+8//77LFmyBMMwuPbaa61kvE+fPlx00UUALFiwgFWrVjFy5Eh69uxpJd/Feb1eZs2axZw5c2jevDn3338///73v7nssssASEpKYvHixbzxxhu8/PLLTJkypVKft34l40qBYWIkSAIuhDh2kcwyDMFW8UGDBoUlc8nJydx8882MGDECgFtuucWazE1Urcos6VbeGuzWDPFFSXtZS7r5DX9w0jV/IZ6AGxMzuH47MumaEEKIuiPm1VeJrWCsdWV5Ro3CW5TIlqV///68//77VjI+ZcoU1q5dy1tvvWX1EszOzi4zGf/mm2/o3bs3sbGxQLABJOTXX39lwYIFFBQU4Ha7K+yVuGPHDjIzM2nevDkAAwcOZMWKFVYy/te//hWA0047jY8++iii76C4+pWMCyFEFatolmHAmkH9SCNGjLCScRFdoSXdymOaRnCGeLzWGuyA9VNH56B2kAOuA0Cwe3ysLVaSbyGEEMfOMIJ/6oFevXrx1FNP8dNPP+H1emnYsCGvvPIKCxcupGHDhjzwwAN4vd6juvasWbN46KGHaN26NVlZWWzatOmYYnU4givL6LqOcRT/fyQZF0IIISIQyRrsMfYY6XouhBDi6AUCaIaBFjCCc1t5vOg+H7rfgx5Q0CixxkLxXnZZha3Y1SE+Pp4zzjiDBx98kP79++NyuYiLiyMxMZHc3Fw+//zzsKF/R+rcuTOzZs3iqquuIhAI8Omnn3LxxRcDUFhYSKNGjQgEAvznP/+hcePG1nsWFhaWuFbz5s3ZvXs3u3bt4sQTT+Sdd94p970rS5JxIYQQoipoGrqsGCqEEKIiSh1Ouv0BNG8w4da8PjSlAA2lKZRuA5sN0+nE1BWaqSq89PFiwIABTJkyhZkzZ9KiRQtat27NqFGjaNKkCR06dCj33NNOO41+/fpx9dVXk5KSQtu2ba1j119/Pddffz3JycmcfvrpVgLev39/HnnkEV5//XUeeOABq3xMTAxTp05l2rRp1gRuQ4cOrbLPqakjp52to3w+X4WzqAZ8Hgp3fo9Pc9ZQVKK45KSkejPDc23jVD4SW3ZCt5X//E1mGq7dIqnnvAUH8eX8gleLqaGoRHFSz0VHaDb1hObl36BJHVf7RVLPFfoLcTvc+F3+GopKFFfRqhGiGNNECxhgBNACgWArt9eH5vMFjxcNY1I2G8oWTLzLGtoU8LlJTW2Es8nJ5b7lsdZz33//fZkrw4ijk5OTQ7t27Uo9Vq0t4+vWrWPWrFmYpsnIkSMZN25c2PE//viDu+66i/z8fAzDYOLEifTp0wefz8eMGTP47rvv0DSNu+++O2ytOSGEEEIIIYSoFULdyo2iruVeH7rXC4FAseRas5JuJZNJiyLVlowbhsHMmTNZvHgx6enpjBgxgr59+4bNejdv3jwGDhzIqFGj2Lp1K+PGjeODDz7g9ddfB2DVqlXs37+f66+/nuXLl6Pr0v1PCCGEEEIIUcOUCibdoa7lPl+we3lR1/LgZJ4aStPBpmPa7RAjvdRE+aotGd+8eTMtWrSgWbNmAAwePJi1a9eGJeOaplFQUABAfn4+TZo0AWDr1q1WS3haWhoNGjTgu+++o2PHjtUVrhBCCCGEEKK+CxvP7bcmUNN8wWERmiJ8PHdMDEiDoThK1ZaM5+TkkJGRYW2np6ezefPmsDLjx49nzJgxLF26FLfbzeLFiwFo06YNH3zwARdeeCF//vkn33//PX/++ack40IIIYQQQohjVzSeWwsEwO8vGsvtDSbdxcZtB7uW21FxcfVmqUqlFFo9+azVraLp2aI6m3pWVhbDhg3juuuuY9OmTUyaNInVq1czfPhwtm3bxvDhwznhhBPo0qULNlv567/abDbS0tLKLRPwefD9YSO+QVJVfgwRIZvdRnKSfPfR4MvPJS0trcIJ3IQQQohaz+vFnrsX02ui7PbgpFe6jtI10Ip+Fu0TIjieO3B4qTCvD93nAyMAHDGe225DJdTviZ5jY2NxuVwkJCRIQn6MlFK4XC5iY2PLLFNtd+bp6ens3r3b2s7JySkxM9/y5ctZuHAhAF26dMHr9ZKXl0daWhpTp061yl1++eW0bNmy3PczDCOi2dQDhkGhzHQbFTLLcPQ4VfD3Q2ZTF0IIUddphoF+KB89oIGp0JR5+GCoFUoDlAZ2G8qmB1s2bTrY7Si7DfTgfit51/XgH0k+6qbQeO5Q0u31ovl8pY/nttswHQ4Zz12G5s2bs2PHDvbs2RPtUI4LsbGxNG/evMzj1ZaMd+jQgezsbHbu3El6ejpZWVnMnj07rExmZibr16/nkksuYdu2bXi9XlJTU3G73SiliI+P59NPP8Vms4WNNRdCCCGEEPWYrqNigi2Y5XYCNc1gwh4IoPkUKDeaaQaTN00rOlsL5u5KBa9rDy0zFUzclcMeTN5DSfuRCbyoOaUtFRY2nluhNIoevtgwY2PlAUslORwOTjnllGiHUW9UWzJut9uZPn06Y8eOxTAMhg8fTuvWrZkzZw7t27enX79+TJ48mWnTprFkyRI0TePhhx9G0zT279/PmDFj0HWd9PR0Hn300eoKUwghhBBCHK90HXRQHB7uWG7yrlQw4TNM8HvRlIlmKsAEtKLJu4qV1bRgwm63B5N3m15613mbLsl7ZRRbKqzU8dyh774o6a5P47nF8aVaB5D26dOHPn36hO2bMGGC9bpVq1YsW7asxHknnngi7777bnWGJoQQQgghRDgtON5c2SqXvAdb371oSoV1nQ92keZwK7x0nQ8XmrW8tPHcRV98cNZyvWh97vo9nlscf2Q2JyGEEEIIIY5GUfIO4Ul7pbrOm+7wce/ldJ1Xdnt48l4Xus4XXyqsaDy37g22cmtm8HMrjcNLhcl4blGPSDIuhBBCCCFETTmGrvOa31s07r1k13mrFf7Ice811XW+tPHcXh+a3w9KFc2pVzRruc2GkvHcQkgyLoQQQgghRK1VHV3nrSS4gq7zNnv4knG6HhzP7fWFjefWPR4IBA7HS7GkW8ZzC1EmScaFEEIIIY5z+fn5fPzxx+Tk5ADBJWh79uxJw4YNoxyZqHLV3HXefuAQjkMHsZYKs+mYdrt0LRfiKNSyQSVCCFG3rFu3jvPPP58BAwawYMGCUsusWbOGQYMGMXjwYO644w5r/2OPPcaFF17IhRdeyJo1a2oqZCFEPbNy5UqGDRvGF198gdvtxu128/nnn3PJJZewcuXKaIcnagM9uP62cjhQMU5UXCxmfHyxPwmY8fEY8fGohARrW8XFopxOK/kXQlSOtIwLIcRRMgyDmTNnsnjxYtLT0xkxYgR9+/alVatWVpns7GwWLFjAK6+8QlJSEvv37wfgww8/ZMuWLaxcuRKfz8eVV15J7969SUxMjNbHEZUVMLC5XNgKCtDzXSz54iC++ESuO7cxgdSU2jeJkqi35s2bxxtvvFGiFfzgwYNceumlDB06NDqBCSFEPSfJuBBCHKXNmzfTokULmjVrBsDgwYNZu3ZtWDL+2muvMXr0aJKSkgBIS0sDYOvWrXTr1g273Y7dbue0005j3bp1DBo0qOY/SH1lGOiuQmwFwYTaVlCALb/odX4BekFB8Fh+gVVGD23nF2Bzu8MuNyv0Yg4omw1/40bBP00a429S9Dq9sbVPEnZRk7RSxuzquh6crVsIIURUSDIuhBBHKScnh4yMDGs7PT2dzZs3h5XJzs4G4PLLL8c0TcaPH0/v3r1p06YNc+fO5brrrsPtdvPFF1+EJfEiAqaJXui2kmdbgSuYQOcfkVhb+13FyhZgcxWWe3mlaZgJCRgNEjASEzEaJOJregJGYgJmg0SMxKL9iQkYDRL5185YEgM+Lkvcg2PPPhx79uLYu4+4n36m4cefBdfOLX59SdhFDbnxxhsZNmwYPXr0IDMzE4A//viDzz77jJtvvjnK0QkhRP0lybgQQlQjwzDYvn07L774Irt37+aKK65g1apV9OzZk2+//ZbLL7+c1NRUOnfujF5B0mWz2ayW9bJ4Ymzs2WsjuWFSVX6M6qEUWmEhen4B+qF8tPwC9EOHgtv5+eiHgj+10HZRudAxraAgOEtwOczEBMwGDTAbNsBskIjZ7ET8DRLxhrYbBH+qUJli+1VCfMSJsA24FrDZbRgBAy/gPeKz6gcOYsvZg213DracPdh37wlu5+zB+ctWbJ+sR/eGnYWy2zCaNMZIb0IgIx0jvQlGRpPgz6J9ZlpqvU/YTTOA8nor/P2or4YNG0bfvn355JNPrAnczjrrLO644w6r144QQoiaJ8m4EEIAGzdu5Pfff8cwDGtfReMo09PT2b17t7Wdk5NDenp6iTKdOnXC4XDQrFkzWrZsSXZ2Nh07duSmm27ipptuAuCOO+7gpJNOKvf9DMOwxpyXxVtwENM0OHDwYLnlqoRSaB7v4dbmUItzweFx1MW3Q2X0gsP7NdMs9y2MuDiMBsFWaSMxAV9aKkaLZta2mZhotVpbLdhFrdVmQvzRTypkGpCfX+nTkpOSyv7udQ0y04N/SqMUtoOHcOzdhyNnL469e4Ot66FW9m+/J27tR5G1sBdvaa8HLezKCBAfY6/w9yPUKlwfJSUlcdZZZ4XNpi6JuBBCRJck40KIeu/OO+9k586dtGnTBltR8qZpWoXJeIcOHcjOzmbnzp2kp6eTlZXF7Nmzw8r079+frKwshg8fTm5uLtnZ2TRr1gzDMDh06BApKSn8+OOP/PTTT/To0aO6PmLplELz+Uok0nqxMdK2YmOk9YKS+7ViDy9KY8TFFiXMwUTZ3ygVo2VzzOJdvBs2KNblOxEzlFQnJIC97szQ+8IPBjExLi4/+SgvoGkYyUkYyUl4Wp9SepkKEvZKdYkv/rNxo+M+Ya/PfvjhB2bMmEF+fj4ZGRkopdi9ezcNGzZkxowZtGvXLtohCiFEvSTJuBCi3vvuu+9Ys2ZNqRMclcdutzN9+nTGjh2LYRgMHz6c1q1bM2fOHNq3b0+/fv3o1asXn376KYMGDcJmszFp0iRSUlLwer2MHj0agMTERB577DHs9mOvkh2//ELMl+tIcHmx5R8xhrrYZGShxFr3+8u9nhkTY42JNhITMJKT8J14QrHW6MOJtnlky3RiAsrhOObPVFf8mKew2/xwcuX+HlVKZRL2UJJeasL+Kbov/P+9JOzHr8mTJzNz5kw6deoUtv/rr79mypQpvPXWW1GKTAgh6jdJxoUQ9V7r1q3Zu3cvTZo0qfS5ffr0oU+fPmH7JkyYYL3WNI0pU6YwZcqUsDIxMTHVsrZ4xlXXYivWVdd0OMK7dDdIxHdCRtG+4vuLJdINEqzWbOV0VnmMopoVT9hPLWNSwCMT9j2hVnZJ2I9Hbre7RCIO0LlzZ9xHrAoghBCi5kgyLoSo9/Ly8hg8eDAdO3bEUawld/78+VGM6uj88da/MX79FnfDVIzERFSMJNOiFFWRsP/4kyTsdUTv3r0ZN24cQ4cOtVaA2L17NytXrqRXr15Rjk4IIeovScaFEPXerbfeGu0QqozRuDE+sxkBLSbaoYi6LtKE/cDB4Bh2SdhrrWnTpvHRRx+xdu1a9uzZA0CTJk0YPXp0iZ49Qgghao4k40KIeq979+7s27ePb7/9FoCOHTvKEkmi0hrFgsNhA8qfIf64omkYKckYKckRJuzFx7FHmLA3aYS/sSTsx6q0ITVCCCGiS5JxIUS9t2bNGh577DG6d++OUor777+fSZMmccEFF0Q7NFGH3HGGneSkBjWzrFxdcrQJ+5691qzxkbSwH7zqUhjdoQY+0PHlnnvu4f777492GEIIUS9JMi6EqPfmz5/P8uXLrdbw3NxcrrnmGknGhagpx5yw70H3eFA1G3WdceDAgVL3K6X46KOPajYYIYQQFknGhRD1nlIqrFt6cnIySsltvaic574ziIkp4KrW0Y7kOFVOwq6MAPExdhKiFFptd84553DCCSeE1WuapqGUIjc3N4qRCSFE/SbJuBCi3uvZsydjxoxh8ODBQLDbeu/evaMclahrfj2ksNsCQDWuMy7EUWjWrBlLlizhhBNOKHFMxpELIUT0SDIuhKj37rrrLt599102btwIwGWXXcaAAQOiHJUQQlSNq6++mkOHDpWajI8dOzYKEQkhhABJxoUQAoDzzz+f888/P9phCCFElRs9enSZx6688soKz1+3bh2zZs3CNE1GjhzJuHHjwo6/8sorvPzyy+i6Tnx8PPfffz+tWgWHEvzzn/9k+fLl6LrOtGnTZF1zIYQoplqT8Yoq7z/++IO77rqL/Px8DMNg4sSJ9OnTB7/fz7Rp09iyZQuBQIChQ4dyww03VGeoQoh66G9/+xuvvPIKXbp0QdMOdy1WSqFpmtVSLoQQxwOfz8e6devYsWMHqampnHvuuSQlJZV7jmEYzJw5k8WLF5Oens6IESPo27evlWwDDBkyhL/97W8ArF27loceeohFixaxdetWsrKyyMrKIicnh2uvvZZ3330Xm81WrZ9TCCHqimpLxiOpvOfNm8fAgQMZNWoUW7duZdy4cXzwwQe88847+Hw+Vq1ahdvtZvDgwQwePJgTTzyxusIVQtRDr7zyCgCbNm2KciTieNA0AZzOerbOuKgz3nvvPZ5//nkGDhxIq1atyM3NZcKECdx55520a9euzPM2b95MixYtaNasGQCDBw9m7dq1YfdziYmJ1mu322093Fy7di2DBw/G6XTSrFkzWrRowebNm+nSpUs1fUohhKhbqi0Zj6Ty1jSNgoICAPLz82nSpIm13+12EwgE8Hg8OByOsIpeCCGq0o4dO8jIyMDpdPLFF1/w008/MXToUBo2bBjt0EQdMr6TrDMuaqeNGzeybNkylixZYvU6bNq0KVdccQVPPvkkF1xwAS1btqRr164lzs3JySEjI8PaTk9PZ/PmzSXKvfTSSyxevBi/388LL7xgndupU6ewc3NycqrhEwohRN1Ubcl4JJX3+PHjGTNmDEuXLsXtdrN48WIgOHZz7dq19OzZE4/Hw5QpU0hOTq6uUIUQ9dytt97KihUr2L59O9OnT6dv377ccccdPPfcc9EOTQghjtnChQuZMWMGMTExZGVl8e2333LmmWfy1Vdf0aVLF/7yl78wc+bMUpPxSI0ePZrRo0ezatUq5s2bxyOPPHJU17HZbGFLTZbGpRvk5u0iuUH5XexF1fMaPjzKiy3ejqlMFCaGMjGVialUiW1TGZio4DZF26poW5mYmKVuG8pAKVXqduj6qui6hjJR1vXDt42i9yuxXfw6R1636P1C1ztyu3icquj9ytq2Pi+lfB/WtUrbLvY9FW0rpZjZ+Q6uaHtmtP8aiCoU1QncsrKyGDZsGNdddx2bNm1i0qRJrF69ms2bN6PrOh9//DGHDh1i1KhR/OUvf7Fa2UsTSeUd8Hnw/WEjXirv8ikFPh+a14fm9R7+6fGi+UI/fUf8LNpfvHyxn9t2uziowSlN4lExTpTTgXLGgNNRtB0T3BfjRDmcRfuc4Dz8OvjHgYoJlg0eKzrP6QS7zEdYFl9+Lmlpaeg2+Y5Ko+s6drud9957jyuuuIIrr7ySoUOHRjssUcfM/SaA05nPuLbRjkSIcH/++SfNmzcH4KeffuLFF1/E6XTi9Xq5/vrryczMZNeuXaWem56ezu7du63tnJwc0tPTy3yvwYMHc++99x7VuRAc5rh///5yy7gP5mEYhvRCiZChDFwBNy6jkIJAIYWBQgqMQlyBQlwBNwWGC1eg6JjhpiAQPFZguCgMuK2yBYFCAioQ7Y9T5TQ0dE1DQ8em6UXbOnroZ9E+m2YrKnd4v1UG3bqGrmnomq3o2OHXmqYVlQu+jwM7uh48N3gs+B6h13rR+4WO2xQ0jU2v8PcjMzOzhr45URWq7c48kgp4+fLlLFy4EIAuXbrg9XrJy8tj9erV9OrVC4fDQVpaGmeccQbffvttucl4JJV3wOchYBgU1pXKWyk0vx/N60MvSo6DP72Ht71eNJ+/6KcP3es74qf3iPP84eeHXSd4nu7zHVPYpsOBcjowY2JQTidmjJN4vyNYeR30W7Fpfn/w/X1+NPPYx1gqXQ++r9OJcgQTdLMoUVeOov1OR9llnE4r9hLnxhQr73BYDxRMR8lrUgsnpnGq4O9HRcl4fa3A7XY7q1evZuXKlcybNw+AQOD4u+EQ1et3F9g9BrLOuKht7HY7BQUFJCYmYpomv/76K23atOG3334jEAjg8/mIjY0t9dwOHTqQnZ3Nzp07SU9PJysri9mzZ4eVyc7OpmXLlgB8+OGHtGjRAsDqZXTttdeSk5NDdnY2HTt2rNbPerxQSuE2vbgCrpJJcsB1eLsowXYVe31kWY/pjeg9Y/UYEuzxJNrjSbDFk2CPJzO2CYn2BGt/nC2WhnEN8Hq9YUlo6HUo4QxLaoslrVqJhPPwcU3TsaGjaUXXpHhSG17uyH3Fk2bdus7h5DcsqdX0w0lz0b66IOBzk5rUKNphiCpWbcl4JJV3ZmYm69ev55JLLmHbtm14vV5SU1PJzMzkiy++YOjQoRQWFvLNN99w9dVXV1eoFVMKLRAokbRaye6RyXCZSW+x/eWdX+ynptRRh11aUlz8p5GQUPJ4TEwwCY2JCSaXMc4jfpayv/j5ZSSjUz4LYLfZuP+sMiq8gFEsOQ8m6PqRCbvPF/z+/KHtI8p4i732+8PPKdpnyy8oOuZDLyqje33WvmP5vkOUzVYs8S8nwS9exukI9ghwOkqWiSn22uFAxVT0wMGJcthB14/5s9QXDz30EMuWLePGG2+kWbNm7Ny5k4suuijaYQkhRJUYOHAgL730EjfccAMPPvggs2fP5sCBAyQnJzNr1izeeOMN+vbtW+q5drud6dOnM3bsWAzDYPjw4bRu3Zo5c+bQvn17+vXrx9KlS1m/fj12u52GDRtaXdRbt27NwIEDGTRoEDabjenTpx/3M6n7TX+xluXwJDn0uvRW6FBLdaiMGzOCySDtmo1EewLxtrhgEm2PJ8WRRLO4TBKKJdWJoZ/2+GJlE4oS7zjibfHY9cj+3yQnJUmvBCGqiKZUFWQfZfjoo4948MEHrcr7pptuCqu8t27dyrRp0ygsLETTNO6880569uyJy+ViypQpbNu2DaUUl1xyCWPHji33vXw+X4Ut44633kRf+zbKb5SeDJfTgnxMSbHdfkQyW5TsWslxTLlJc9jx8pLi4vudtauFtsJkvDZQCgzjiOS/WOJ/5EOA0h4W+Is/APCXXqbYwwK9RJnguVXBdDiKEnYHB4ech+fB2dIyXg0qWsIRYM2aNcydOxdN02jTpo31YPLRRx/lo48+wjRNevTowd13313uE/pI6jlvwUF8Ob/g1WKO7YOJSqsT9dxxShkB4mPsJDTvUG65+lrH+Xw+xo0bx8CBA7nsssvCjq1YsYKVK1eyaNEinE5nlCI8LJJ6zn1wH4F92/FqVROvoQwKDY/VCh1MiN0lE+gjEubiZUMJtl9V/G+4hhZMgIu1Qh+ZJCfY4g63UhcrY5UtSrCduqPGW3YlGY+OgM9NamojnE1OLrdcfa3n6qoy78xzc3PJzc0Nm/0cYOvWraSmppKamlrhxfv06UOfPn3C9k2YMMF63apVK5YtW1bivISEBJ566qkKr19Z8atWEfPhhyWS4lDiayYn4T+ypbespPjI/XUkKRbl0DSw2zHtdoiPYhyh4Qn+4ol/sWT/yB4A3vAeA6Ul+J42raP4gWqvCRMmMGfOHIYMGVLq8VWrVpV7fiRLOGZnZ7NgwQJeeeUVkpKSrJvMjRs3snHjRt566y0ARo0axZdffslZZ51VRZ9OCCGCnE4nCxYsYMGCBYwcOZLMzExsNht//vknZ511Fs8991ytSMQrQylFoekJjn8uljCHt0i7KQiUMh76iLJuwxPRe8bqMcTb48JamTNim1gJc6Itvuh4sFt3whFl422Hu3rrmvReE0KUk4zff//9jBo1qsT+AwcOMG/evBJdzuuC/c/MpXDn9/iq6EmqiNzJDTViYuyAEe1Qaj9Ns8awk1A135hT+ZDFAUu6++67AZg/f/5RnR/JEo6vvfYao0ePJikpOHFkaKJJTdPw+Xz4/X6UUvj9fho1krFgdZnUc6I2czqdjB8/nvHjx5ObmwsQUcNKbVMYKOS8NReRnb8jom7cNk0vak1OsBLmZEdDTozLKNYifbgFusS2LZhUx9vicegyCaoQomqVWats376dM88sOXV+t27drFkyhYjU9e1tJCclSrcmUas0adIEANM0adKkCTExwa7dHo+Hffv2VXh+JEs4ZmdnA3D55Zdjmibjx4+nd+/edOnShbPOOouePXuilOKKK67glFNOqaJPJqJB6jlRF2zcuJHff/8dwzj80KgurR7h1J2MOGkohw79Tqy9QVHCnFCixTo0VjpGd9aZCbqEEPVPmcm4y+Uq8yS/v2rGtAohRG0wYcKEsCEzuq4zYcIEVqxYcczXNgyD7du38+KLL7J7926uuOIKVq1aRV5eHtu2beOjjz4C4LrrrmPDhg1069atzGtFsoSjJ8bGnr02khvKEo7RYLPbSE6S776mmWYA5fVW+PtR3915553s3LmTNm3aWBOpaZpWp5Jxu27nhrbXVemYcSGEiJYyk/EWLVrw0UcflRjz/dFHH5W7xJgQpZm9MYDDkc//lT+3jhBRYRhG2HhJp9MZ0UPHSJZwTE9Pp1OnTjgcDpo1a0bLli3Jzs7myy+/pFOnTiQkJADQq1cvNm3aVG4yHskSjt6Cg5imrL8bDcF6zsn/dTj2pRpF5YQmcJP1d8v33XffsWbNGmkpFkKIWqLMZHzq1KnccMMNvP3227Rr1w4IVuJff/31UY+vFPXXPg/Y/bL+rqidUlNTWbt2Lf369QPg/fffJyUlpcLzIlnCsX///mRlZTF8+HByc3PJzs6mWbNm7Nq1i9dee41AIIBSiq+++iq6SziKYyb1nKjtWrduzd69e60hOkIIIaKrzGS8ZcuWrFq1ilWrVvHLL78AcOaZZzJz5kxrXKUQQhwP7rvvPiZOnMjMmTPRNI2MjAxrndzyRLL+bq9evfj000+tdXYnTZpESkoK559/Pp9//jlDhgxB0zR69epV5jq/QghRFfLy8hg8eDAdO3bE4XBY+6WRRQghoqPCdcZ37tzJ1q1bgeBSZLW1i3ok61IGfB6ZTT1KZP3d6HIqH4ktO8k64xUIzZUR6jpe28g647Wb1HPRI+uMR+bLL78sdX/37t1rOJKyRWOdcVE5ss54dMg648enMu/MCwoKuPvuu/n+++9p27YtSil++OEH2rVrx4MPPkhioiyUJERNM5WJx/ThMTx4DC8e04vH8OI2PNZrj+HFbXqs1x7Ty1+ST6d/y07RDr/W2rdvH0888QR79uxh4cKFbN26lU2bNjFy5MhohyaEEFWme/fu7Nu3j2+//RaAjh07yqR3QggRRWUm4w888ACtWrXiH//4B7quA6CU4plnnmHmzJk8+uijNRakqPvapGjExDiAQLRDqRZKKQIqgNtKkD1FSXEoQfYUS5y9eI5Ilt2GJ7i/RFIdvs9r+iodm45O4YmD6M9V1fDJjw+TJ0/mkksusbpqtmzZkr///e+SjItKOd7rOVH3rVmzhscee4zu3bujlOL+++9n0qRJXHDBBdEOTQgh6qUyk/GNGzfy8MMPh+3TNI3x48dz3nnnVXtg4vhydVsbyUkJUenWVFprctnJb3iS7AmVK1bGY5a+z1CVn0E5RncSa4shVo8h1hZLnB4T3LbFkOxoGNxnHQ+WidVjgvuKnRdriyl27uEycbZY7JqdGGQ5wvLk5eUxaNAgFixYAATHgoceQgoRqWjWc0JEYv78+SxfvtxqDc/NzeWaa66RZFwIIaKk/AGkZahgmLkQEVFK4Vf+Yq3FkbQoe49IqquvNTmuKMkNJb3BpDiWZEcSGbHF9hUlv6GycfqR58UevlaxhDlGd2DTbNXwzZZCfmXLFR8fT15enrXcz9dff02DBg2iHJUQQlQtpVRYt/Tk5GS5pxNCiCgqMxnv0qULc+fO5ZZbbglbj/KZZ56hc+fONRGbqEMKA272+/KK/hxgny+X/d4D7Pflkes7wNe5+wngJsERnjib1ExrciiRjrRF2a7ZZR3WemTy5MncdNNN7Nixg8svv5y8vDzmzJkT7bBEHfPgVwGcjkNM7BztSIQoXc+ePRkzZgyDBw8Ggt3We/fuHeWohBCi/iozGb/nnnuYOnUqAwYMoG3btgD88MMPnH766TzwwAM1FqCInooS7H2+XPb7gttuw1PqNVIcSaQ6k0ElE683omtKbKValI9sTY7VneiadB8WVccwDL766iuWLl3Kb7/9hlKKk046KWzZHyEike8Hu2ki64yL2uquu+7i3XffZePGjQBcdtllDBgwIMpRCSFE/VVmMp6YmMhTTz3Fjh07rKXN7rzzTpo3b15jwYmqV16CXXx/WQm2hkayoyGpzmQaxaTQMakNac4U0pzJpDlTi36m0CgmhRRHMnY92A3bWvKnndykitrFZrOxevVqrrnmGlq3bh3tcIQQolqdf/75nH/++dEOQwghBBGMGW/evHlYAv7bb7+xaNEiaR2vRYon2PtCCfVRJNhpzhTSYpKLJdgpxRLtkgm2EMeLM844g5kzZzJo0CDi4uKs/e3atYtiVEIIUTX+9re/8corr9ClS5ewIVhKKTRNs1rKhRBC1Kwyk/Eff/yRRx99lD179tCvXz9Gjx7N/fffzzfffMN1111XkzHWS5Em2Pu8uXhMb4nzI0mwG8UEW7IlwRb13Q8//AAQNk5c0zT+9a9/RSskIYSoMq+88goAmzZtinIkQgghiit3zPjf/vY3OnfuzLp16xg6dChDhw7l8ccfJyYmpiZjPG6EEux9xRNq7wH2Fxt7XdkEu5EzhdQ6kGB3aqQRG+MEWWJL1EIvvvhitEMQdYzH8LLbs5fd3r3kePay27OX3/W9gMmMLcH62qbp6JoNHQ1d07FpOpqmY0NH14r+ENqvYdNs6OjoWlF5bNbr4mVDr61rUnSuVnQuZbxXKdt6WXGW8V6lvbdMdll37Nixg4yMDJxOJ1988QU//fQTQ4cOpWHDhtEOTQgh6qUyk3Gfz8cll1wCwMknn8yLL77IpEmTaiywuiKSBHufL4/93ryjSrAbxRxOtGtbgl0Zl59qIzkpXtbfFbVSXl4ezzzzDP/73//QNI0zzjiDW265hZSUlGiHJqLAbwbY491XItkObu8jx7OXPH/JuizFkUS8I44/9wcwlYmBiVIKQxmYysREBfcrE0XoZ91fVkq3EvzQg4BiDxGKJ/LFHgQcfogQ+YMATdOKHlCEP3QIPVS4vPlA+jfvEO2vo1a79dZbWbFiBdu3b2f69On07duXO+64g+eeey7aoQkhRL1UZjLu9XrZsmWLtf6k0+kM2z6ex1KWlmDv8+aRW2zsdWUS7M5Jp5PmTD7uEmwhjhe333473bp146mnngJg1apV/P3vf2fJkiXRDUxUOVOZ7PPlWcl1TlHCbW1797LXm1siSW5gTyAjtgkZMY3p0PBU0mMbkxHTmIzY4J/0mMbE2JwkJyVV6qGjUgoT00rSgwl7UfKuFAZm0XawnKFMlFXWLCp3OLEvnvgbqujcUh4ChM47fM2icwm+b/BhglG0P7zskeeaxWI5HEcp7130gCLS9w699pt+vGHvFfyOjnyvnu4uVf3X5bij6zp2u5333nuPK664giuvvJKhQ4dGOywhhKi3ykzGGzduzEMPPWRtN2rUyNquq2MpD/kOsfnAFnb7C6o0wW7kTCFNEuxyzfg8gMNxkGldox2JECXt3buXW265xdq++eabefvtt6MY0TEyTLSAB3QdpeugaRD6eRxTSnHQn8+fnj3hLdrFku093v0EVCDsvFg9xkqq/5LQNZhoh/4UJdwJ9vgK3/9o6rlQa69NsyGL6R09ZQSIj6lwTtp6z263s3r1alauXMm8efMACAQCFZwlhBCiupT5L9fxOIby6vfH8L89/7O2iyfYjWJSJMGuRj4TzIBC1t8VtVGPHj3Iyspi4MCBALzzzjv07NkzylEdHeV0EMhognnQjRYwwAigGQaa1wsU/Q4qFZaYBxN2HXQt+LqWJu4FAVex7uJHJtvB7uNHPky1a3aaxKSRGduELsntrFbs4sl2kqNBlYx7lnpO1HYPPfQQy5Yt48Ybb6RZs2bs3LmTiy66KNphCSFEvaWpUL/zOs7n87F///5yy/y0dwtbf/uUpJjGNHKmkOxIkgS7hljrjJ8lN6nR4FQ+Elt2QreV33KUmZlZQxHVLl26dMHtdmOzBesDwzCsJc5q07I/kdRznoAHl92F31XKZImmCaaJZpigTDRTBZP1gAGBAJphogX8wW3TRAOUpqEpUEW/uqooaUfTULot+FrXj/mzeQ1feHfxUrqP5wdcYedoaDSOSS3qPt4omGgf0X08zZmCrh17fJGQei56Qi3jCRWMGa+vdVxdEkk95z64j8C+7Xg1Zw1FJYqr7HAcUTUCPjepqY1wNjm53HJSz9Ut9apP1ylJJ5OZ5sYnlbcQoph6s9xPUau3Kqr5y30SqxQYRjBhV0UJvGkG9wUCaP4AmhFA85vBRF7Tiq4XahlWgI6y6fiVwZ7AAXZ797Hbt8+aBK14sl3WhGgZsY1pFp/JmSkdS3QfbxyThkOvV/+MCXFUJkyYwJw5cxgyZEipx1etWlXDEQkhhIBqTsbXrVvHrFmzME2TkSNHMm7cuLDjf/zxB3fddRf5+fkYhsHEiRPp06cPb731FosWLbLK/fTTT/z73/+mbdu21RmuEEJUWkX1HMCaNWuYO3cumqbRpk0bZs+ezeeffx42L8evv/7KP/7xD/r371+T4ZdN08ButxL2shJ3U5nsd+8jp2A3Oa4/yXHtZrcrh5zCHHLcOewu3MM+by4mZth5ibZ4MmMakeFsRPvUk8lwNgpLtpvENSHWEVcru8sLUdfcfffdAMyfPz/KkQghhCiuzGT8448/xuVyccEFF4Ttf+edd2jQoAE9evQo98KGYTBz5kwWL15Meno6I0aMoG/fvrRq1coqM2/ePAYOHMioUaPYunUr48aN44MPPuCiiy6yxjD99NNP3HLLLZKI13FnpmvExco64+L4Ekk9l52dzYIFC3jllVdISkqyul+effbZvPnmmwAcOHCA8847r8J6taYppTjoO0iOK4fdhbuDCXbx10V/Amb4BFAxthjS49PJSMjgrJRTyIjPID0hPbgvPoP0uMYk2uLL7i4fKBrn7vEEW+OLEvJSu8vretjraJJ6TtRWTZo0AcA0TZo0aUJMTAwAHo+Hffv2RTM0IYSo18pMxp955hmeffbZEvu7d+/OTTfdVOFN4+bNm2nRogXNmjUDYPDgwaxduzbsJlXTNAoKCgDIz8+3/rEoLisri8GDB0f2aUStdckpss64OP5EUs+99tprjB49mqSkJADS0tJKXOfdd9+lV69e1jj1muLyu8gpzGG3K5hc7y7cTY7rcJK927Ubj+EJO8eu2Wkc35j0+HQ6NupIeny6lXiHXifHJEc0IVpE3eVD49xL6y7vD45v14wAms8I7ivqLq8phdLCu8sHx7nrVnf9qib1nKjtJkyYwLJly6xtXdeZMGECK1asiGJUQghRf5WZjPt8PlJTU0vsT01NpbCwsMIL5+TkkJGRYW2np6ezefPmsDLjx49nzJgxLF26FLfbzeLFi0tcZ82aNaU+FDiSzWYr9Sa3uIDPg+8PG/ENkiq8nqh6NruN5CT57qPBl59LWlpahRO41WcbNmxg+/btDB8+nNzcXFwul5VklyWSei47OxuAyy+/HNM0GT9+PL179w4rk5WVxbXXXls1H6SI1/BaLdlHJtqhlu18X37YORoaaXFpZMRn0Cq5FT1O6BGWaGfEZ5Aam4qtJie+DI1zL9qscJy7lbwXS+Kt1vaiCer8fggYRU3tFE1+HpplXkfpWvCnrf4sCyfqB8MwcDoPz5vjdDrx+6UnhxBCREuZd+Yul4tAIIDdHl7E7/fj9ZZch/toZGVlMWzYMK677jo2bdrEpEmTWL16NXpRi8U333xDXFwcp556aoXXMgyjwtk3Az4PAcOgUFotapzMMhxdThX8/ZDZ1Es3d+5cvvvuO3777TeGDx+O3+/nzjvvDGtBOlqGYbB9+3ZefPFFdu/ezRVXXMGqVato2LAhAHv27OHnn3+OaCm1SB46/u3ff+Oj7R+x312yPkyJTSEzMZOWKS05p9k5nJB4ApmJmWQ2yOSExBNoktAEp60eTXBZ1MJuJe2GAaYR7C5f1OpOUZd5TCO4/JtSVtIO6nDSruvc+kEBmn6QpwbIQ8eaZpoBlNdb4e9HfZeamsratWvp168fAO+//z4pKSlRjkoIIeqvMu/MBwwYwD333MM999xDfHw8EEzQZ82axYABAyq8cHp6Ort377a2c3JySE9PDyuzfPlyFi5cCASXFvJ6veTl5Vn/mEoXdSFETXjvvfdYuXIlw4YNA4L1l8vlquCsyOq59PR0OnXqhMPhoFmzZrRs2ZLs7Gw6duwIwNtvv82AAQNwOBwVvl8kDx0zYzL5a4u/0sTZJNhtPCHYot0kvglx9nK6wRvgOuTCRcWf+7inAU5H8E9I8ZZ2s2iWedNECwTA50UzTAIBA7tNcejPPwFQNhvKbgebLKFZ3UJLm1X4+1FPHziG3HfffUycOJGZM2eiaRoZGRk88sgj0Q5LCCHqrTKT8dtuu40nn3ySc889l6ZNm6KU4s8//2TEiBFMmDChwgt36NCB7Oxsdu7cSXp6OllZWcyePTusTGZmJuvXr+eSSy5h27ZteL1eq2u8aZq8/fbbvPzyy8f4EYUQonwOhwNN06xxzpEMxYHI6rn+/fuTlZVldX/Pzs4O6/6elZXF7bffXmWf5Y6ud5S9zrg4emHd5R2ldpdXMftQdjv+pmnB8exuN7rbje71oghOOqccdrDLcBERHc2bN+e1116zHjYmJCREOSIhhKjfyrwjsNvtTJw4kfHjx7N9+3YAWrRoQWxsbGQXttuZPn06Y8eOxTAMhg8fTuvWrZkzZw7t27enX79+TJ48mWnTprFkyRI0TePhhx+2boa/+uorMjMzKxyzKYQQx2rgwIFMnz6dQ4cO8dprr7FixQouvfTSCs+LpJ7r1asXn376KYMGDcJmszFp0iSrW+iuXbv4888/6d69e3V/RFFTNFBOB8rpgIR4DAh2dff70b0+9MJCNJfLGqeu7PZg63mUZ4IX9cO+fft44okn2LNnDwsXLmTr1q1s2rSJkSNHRjs0IWqXojlIgvOPFE0gGnptmmjFjysVHM6kFJgKzTSCP1Wx8qFyRb2sDh8/PEEpRrHrKgXFVxwxTcyAD+38WrL8qagymlKq1Plw/vOf/4QX1DRSUlJo06YNiYmJNRJcZfh8vojGjBfu/B6fVo/GRNYSMmY8upzKR2LLTjJmvByffvopn3zyCQA9e/asdcuMQWT1nCfgkZbxKJm2eh92h517z08uv6BpBlvOfT70Qg+62x28iUO6th+tUDf1hOYdyi1Xn+s4gLFjx3LJJZcwf/583nrrLQKBAMOGDWPVqlXRDs0SST3nPriPwL7teOV+rmophe72oBcWYnO50F2F6IVubK7Con3Bn3F2Ox6320oSSySnVvJabFiPCn99OCk9nHiGklfrmCr9tZW8FiurhU3geUTyHFqJo7xrFHutmWa0/0+UKfeu2/BOmFRumfpez9U1Zd6Z//e//y2x78CBA/z000/MmjWLc845p1oDE8eXnidoxMfGAL5ohyJEqXr06FErE3BRd/Q4Oc6aY6Vcuo6KiUHFxGA2aBC8QfQHyu/abrPJjO7imOXl5TFo0CAWLFgABHv36NIro25TCs3nDybLhYXFEuhgMm0rLJZQuwrRC13YCt3BY0XJ9eFE2x1MaiOQBMGlIostGRlaiQK92L7QihSh1zYdVVSm+KoV1rKTodeaVnTs8PWUwxF+vdA19DKuV8o1yoqv5DWKymka6Lai99JQobq4tM8Tuo4W/rrE92Mr9r5F17BW8tBLv57Sdf77u4G71WlcVr1/o0QNKzMZf+ihh0rd//vvv3Pbbbfx+uuvV1tQ4vgzuKWN5KQ4DhyUZFzUPl26dCmxLnaDBg1o3749kydPluEyIiIDT08gJSWFvLy8yp2oaSW7tofWUff6sLlcaIWF0rVdHLP4+Hjy8vKs+u7rr7+mQYMGUY6qnjKMI1qdXeihJLkoqbZ+FiXKxVusbUXbuqsQPRCo8O2UpmEmxGPEx2MmxGPGx2MkJuBv0hgjPi54rGi/GV/0ulh567y4OJIapXHg0CF5QFjDujdzk5oa2XBhUXdUehaZpk2bEojgl16I4jwBhScQ2dNWIWra1VdfTUZGBhdeeCEQnFRtx44dtGvXjqlTp/Liiy9GOUJRF3gDJh5/FXVvtNmCXdZjYzGTGhZ1bQ8Eu7YXdSPFNK2WGunaLiIxefJkbrrpJnbs2MHll19OXl4ec+bMiXZYdUexbtxWa3IoMXa5rFboUludQ/vcRa3WnsiWCTZjYzASEoIJclHS7Dsho/SkOT4OMyGhKKmOs5JrIyEBFRtTdclzqPVX1CivEbyflsEZx5dKJ+O//vorTqf8NRCVc9+XBnbbQRkzLmqlDz74gLfeesvavuyyy7j44ou58847mT9/fhQjE3XJ/e/kYnccqnjM+NHQdVSMExXjxGyQGBx/GQig+wOHu7Z7PMDhru3KbpcbZmExDIOvvvqKpUuX8ttvv6GU4qSTTopoWcW6Ljg/Q3mtzkcm18W7dgdbrEP7IhlPbNrth1ufixLjQGoKvhObWtuHW6ITrCT7cFJddCwuDuzykE0E3f8/Gw5HAfP+Fu1IRFUqMxm/8cYbS+w7ePAge/fu5dFHH63WoIQQoibFxcWxZs0aLrjgAgDeeecdYmJiAEp0XxeiVtA0cDgwHQ6IjyvRtT2UXATLgrI5gmPPpWt7vWWz2Vi9ejXXXHMNrVu3jnY4R08p4j5ch23L1yi3L9hN22p1LtkKrbsK0f0VT2h5uBt3XLDVOSGYJPsbp4V37T4iyTYSEoqOxVnllDRaCSEiVGYyft1114Vta5pGcnIyLVq0kJZxIcRx5fHHH2fWrFncd999aJpG586deeyxx/B4PNxzzz3RDk+IyETatZ3QrO0OaXWrZ8444wxmzpzJoEGDiIuLs/a3a9cuilFVjuZy0eTvE62eIFY37rg4q8u2P6MJnlDX7uIt0cWS7CPHSJtxsdKTRAhR48pMxsta93bDhg1kZWUxY8aMagtKCCFqUrNmzcrsjt6tW7cajkaIKnJk13YAvz+8a7tLurbXJz/88ANA2DhxTdP417/+Ve5569atY9asWZimyciRIxk3blzY8cWLF/P6669js9lITU3lwQcfpGnTpgA8+uijfPTRR5imSY8ePbj77ruPqceRSkxk+yf/xdiTjTs+SR4oCSHqtIjGjG/ZsoVVq1bx7rvv0rRpU84777zqjksIIWqM1+tl+fLl/PLLL3i9hyfVKWtVCSHqLOnaXq/NmTOH1NTUSp1jGAYzZ85k8eLFpKenM2LECPr27UurVq2sMm3btmXFihXExcXx8ssv89hjj/Hkk0+yceNGNm7caM3JMWrUKL788kvOOuusY/ocKiEh+IBJk0RcCFG3lZmM//bbb2RlZbF69WpSUlIYNGgQSimZVVgclX7NdOLjYoHIZg8VoibdeeednHzyyXzyySfccsstrFq1ipNPPjnaYYk6pu+p8cQnRLDOeG1yZNf2ojWLpWv78eWDDz5g6tSp1rriTz75JGeccUZE527evJkWLVpYSzwOHjyYtWvXhiXjZ599tvW6c+fOVvKtaRo+nw+/349SCr/fT6NGjarwkwlRf/RtapKQIEOFjzdlJuMDBw6kW7du/POf/6RFixYALFmypKbiEseZ/s10kpNiOXBQknFR++zYsYOnnnqKtWvXMmzYMC688EJGjx4d7bBEHdP31PijW2e8NtE06dp+HPrHP/7BSy+9xCmnnMI333zDY489xtKlSyM6Nycnh4yMDGs7PT2dzZs3l1l++fLl9O7dG4AuXbpw1lln0bNnT5RSXHHFFZxyyinH9mGEqKf6NlWkpsZEOwxRxcpMxufOnUtWVhZXXXUVvXr1YvDgwSgl60SLo3PQq8BTRevvClHF7PZgVdiwYUN+/vlnGjVqxP79+6MclahrDnkMtMJAtMOoetK1vc6z2+1WEtypUydcLle1vM+bb77Jd999ZyX627dvZ9u2bXz00UdAcHLgDRs2lDsXh81mIy0trdz3cekGuXm7SG6QVHXBi4jZ7DaSk+S7r2n7Djk45IfTKvj9EHVLmcl4//796d+/P4WFhaxdu5YXXniB3NxcZsyYwYABA+jZs2dNxinquIf/Z2C3HZJ1xkWtdNlll3Hw4EFuu+02brrpJgoLC5kwYUK0wxJ1zKPv52F35FfPOuO1iXRtr3P279/P4sWLy9y+9tpryzw3PT2d3bt3W9s5OTmkp6eXKPfZZ58xf/58li5daq26895779GpUycSEhIA6NWrF5s2bSo3GTcMo8KHoe6DeRiGwYGDB8stJ6pHclKSfPdRMO0THw6Hl3lNy//9yMzMrKGIRFWocAK3+Ph4hgwZwpAhQzh48CDvvPMOzz33XN1Nxk0TLeBD2W1gk5sDIeo70zRJSEggKSmJM888k7Vr10Y7JCHqlvK6tns86IVutEIPmpKu7dFy6aWXhrWGH7ldng4dOpCdnc3OnTtJT08nKyuL2bNnh5XZsmUL06dPZ+HChWGt2ieccAKvvfYagUAApRRfffUVV199ddV8KCGEOA5ENJt6SFJSEpdddhmXXXZZdcVTvWw2jIwmmPvz0b1eNI/HuhlQmg52m9wgCFHP6LrOwoULGTRoULRDEeL4Ubxre2rKEV3bg2PPg5R0ba8B48ePP+pz7XY706dPZ+zYsRiGwfDhw2ndujVz5syhffv29OvXj0cffTSsR1FmZibz58/n/PPP5/PPP2fIkCFomkavXr3o27dvVX0sIYSo8yqVjNd5mobZIBFDjwmOezNNNH8AzTDQvF40jxfd40ELda/TNJTNjrLZpIudEMexv/zlLyxatIhBgwYRFxdn7U9OTo5eUEIcT8rp2q55PNgK3Ye7tuu6dG2vZfr06UOfPn3C9hUfylPWBL82m42ZM2dWZ2hCCFGn1a9k/Ei6HuxaBxB/+AacQAAtEAgm6h5PsBXdVdSKrhRKDybnymaTJ/lCHAfWrFkDwEsvvWTt0zRNuqwLUV2KdW2nQWLwAXmpXdu14INx6douhBDiOFS/k/Gy2IP/6KtYDt8kmCZawAgm6T7fEa3oGkormqjGZpen+aUY1EInPj4O8EQ7FCFK+OCDD4763HXr1jFr1ixM02TkyJGMGzeuRJk1a9Ywd+5cNE2jTZs21njLP/74g2nTpvHnn3+iaRoLFizgxBNPPOpYRHRd0DaBhMQEQFaOOCrStV0IIcp0QTOTxERZ2ux4I8l4pHQd5dRRTkfJVnTDONyK7ilqRYfgk39NB5sefKJfj28aejXVSU6K4cBBScZF7eN2u1m8eDF//vkn999/P9nZ2fz222+ce+655Z5nGAYzZ85k8eLFpKenM2LECPr27UurVq2sMtnZ2SxYsIBXXnmFpKSksFmC77rrLm688UZ69OiBy+VCr8d1xPGg5ylxpKQk1e11xmuTsrq2+/1objc2twcMAyh6/BEjtzRlKT5zemnKm01dCFE79MxUpKY6ox2GqGLyL9exCrWix8RAYkKwFV2pYHIeCAS73bmLurqbJihQmioai15/WtH3uhVeu4E8zxO10ZQpU2jXrh2bNm0Cgkv5TJgwocJkfPPmzbRo0YJmzZoBMHjwYNauXRuWjL/22muMHj2apKI1WUMzDW/dupVAIECPHj0ArKV/RN21r8DAb/PjiHYgx6viXdtD/94WdW1X7kLMxPhoR1hrhWZO/+233/j222+tSdT++9//0qFDh2iGJoSI0D43BFwm0n/u+CLJeHXQNJTTEWxFJy74RB+CXe7KGosePBEVmtH9OGshe2KTgd2WL+uMi1ppx44dPPnkk2RlZQEQFxeHUqrC83JycsjIyLC209PT2bx5c1iZ7OxsAC6//HJM02T8+PH07t2b7OxsGjZsyPjx49m1axfnnHMOEydOxCZLLtZZT35YT9YZr02KurabcTGYDRNkhEAZQrOpjx49mjfeeIPExERr/w033BDN0IQQEXryWxsOh4t5J0U7ElGVJBmvSaEud6W0omME0Hx+dI83mKQHAgBFY9GLZnS32WTyGiGqgdPpxOPxoBX9fu3YsQOns2q6ghmGwfbt23nxxRfZvXs3V1xxBatWrSIQCLBhwwZWrlxJZmYmf//733njjTcYOXJkmdey2Wxha/iWxhPw4CnwkJiSWCXxi8jZHQfQNI2UlJRoh1LvmMrExCQtpfzfj/pu3759YXWb0+lk3759UYxICCHqN0nGo62oFR0cqLg4zKSi/aFW9IBRNBbdgxaavEYp0PTjthVdiJo2fvx4xo4dy59//skdd9zBpk2beOihhyo8Lz09nd27d1vbOTk5pKenlyjTqVMnHA4HzZo1o2XLlmRnZ5ORkUHbtm2tLu79+vXjm2++Kff9DMMIG3NeGk/Ag2E3yDsk45ZrWsAfwO6wy5jxKDCVSULDhAp/PzIzM2sootpp6NChjBgxggEDBgDw/vvvc8kll0Q5KiGEqL+qNRmvaJbhP/74g7vuuov8/HwMw2DixInWOpY//vgjM2bMoKCgAF3XWb58OTEx9WjEsdWKDiTEW63oh5dd86N7fOgeDxgB6zSlFyXo0oouRMR69uxJu3bt+Oabb1BKcffdd5OamlrheR06dCA7O5udO3eSnp5OVlaWNVN6SP/+/cnKymL48OHk5uaSnZ1Ns2bNaNiwIYcOHSI3N5fU1FS++OIL2rdvX10fUQhRzymlGDp0KL1792bDhg0APPTQQ5x++ulRjkwIIeqvakvGI5lleN68eQwcOJBRo0axdetWxo0bxwcffEAgEODOO+/kscceo02bNuTl5WG3SyM+mgYOB8pR1IpeNBQ92Ipe1JIeGovudhe1oGtYY9FDXd2FEGFuvPFGLrzwQvr27Ut8fOSTQNntdqZPn87YsWMxDIPhw4fTunVr5syZQ/v27enXrx+9evXi008/ZdCgQdhsNiZNmmR1Y77rrru4+uqrAWjXrl25XdSFEOJYaJrGuHHjWLVqFe3atYt2OEIIIajGZDySWYY1TaOgoACA/Px8mjRpAsCnn37KaaedRps2bQBk/F1FrFZ0Z+mt6IEAuju4LjreoqXFVNG66DXUij7sZJ2EBFlnXNRO1113HWvWrGH27Nl06NCBQYMGce6550bUG6dPnz5Wj56QCRMmWK81TWPKlClMmTKlxLk9evRg1apVx/4BRK1wcYfEoomxAhWWFSIaTj/9dDZv3kzHjh2jHYoQopIubmmS2CA22mGIKlZtyXgkswyPHz+eMWPGsHTpUmudXwguvaFpGmPGjCE3N5dBgwZx/fXXV1eox6fireiA2aBBcL9pWsuuaV4vmteLHhqLXkTZ7Ch71baid8+QdcZF7dW9e3e6d++OYRh8/vnnvPbaa0ydOpWNGzdGOzRRh5zZIpaUlAYyZlzUWt988w2rVq3ihBNOIC4uztovDwWFqP3ObKJITZXFM483Ue37nZWVxbBhw7juuuvYtGkTkyZNYvXq1RiGwf/+9z+WL19OXFwc11xzDe3bt+ecc84p81qRzDIcMAO4DrlkluEjWa3oBvh9aIVuNI83OMO7GZwsDj04YRx2+1G1ou84GKDApTgxKaniwqLK+fJzSUtLQ7fJcI+yeDwePvjgA95++22+//57hg0bFu2QRB3z+4EA+cpLA5muQ9RSixYtinYIQoij9LsLCuwGrZpEOxJRlartzjySWYaXL1/OwoULAejSpQter5e8vDwyMjI488wzrQmUevfuzffff19uMh7JLMMBM0BAD8gswxWJcQb/FG9F9/nQCgrRvb7gcmxKoTQt4lb0hz4LYLfZZJ3xKHGq4O9HRcl4fZ1peMKECXz77bf07NmT0aNH0717d3RZpUBU0rxPDmB3FMg646LWatq0KQD79+/H6/VGORohRGXM+96Gw1HIvFYVlxV1R7XdbRafZdjn85GVlUXfvn3DymRmZrJ+/XoAtm3bhtfrJTU1lZ49e/Lzzz/jdrsJBAJ89dVXYWPNRQ3RdVSMEzMhHiMlmUBmBr4WzfA1a4rvhAwCjVIx42LQTAPd5UIvLEQvLERze9D8/mCLuxB1wIgRI3jvvfeYOXMmZ599Nhs3buS+++6LdlhCCFGl1q5dy3nnnUe/fv244oor6Nu3rwwDFEKIKKq2lvFIZhmePHky06ZNY8mSJWiaxsMPP4ymaSQlJXHNNdcwYsQINE2jd+/e/PWvf62uUEVlaBrY7Si7HRUbCw0aBCeMC7WiG0ZwLLonOGGcZprB04xg93bNa5Rx3QreswyqzGPlXPAo3+uoj4lar1evXmzZsoXVq1fzzjvv0LRpU84777xohyWEEFVqzpw5vPrqq1x77bWsXLmSzz//nLfeeivaYQkhRL1VrQNIK5pluFWrVixbtqzUcy+++GIuvvji6gxPVKWiVnQFEH94UpjQjO7q24Ng0zHjSv6V08prQC9K5kulSj+mKVXmMRRlt9grVXYsSpVzXjnXtAqUodxnBmUcLBoiUNaxUh8MJDjlgUEpfvvtN7Kysli9ejUpKSkMGjQIpRQvvvhitEMTQogqZ7fbSUlJwTRNTNPk7LPP5sEHH4x2WEIIUW/JbE6ieoVa0W0FKIcdo3FytCOqeeUl6jV0TCVKMl6agQMH0q1bN/75z3/SokULAJYsWRLdoIQQopo0bNgQl8vFmWeeycSJE0lNTSU+Pj7aYQkhRL0lybioESO7NChaf9cf7VBqXm3o3m63l9tAX1/NnTuXrKwsrrrqKnr16sXgwYNRMteBOEr1up4TdcKzzz5LbGwsU6ZMYdWqVeTn53PLLbdEOywhRARGnmLSQNYZP+5IMi5qRKemMaSkJMr6u6JW6d+/P/3796ewsJC1a9fywgsvkJuby4wZMxgwYAA9e/aMdoiiDpF6TtRW27dvZ9++fXTt2hUAXdcZNmwYGzZsID8/n5SUlChHKISoSKc0WWf8eCRr94ga8dt+P7/kuKMdhhClio+PZ8iQIcyfP5+PPvqI008/neeeey7aYYk6Ruo5UVs9+OCDRb02wjVo0KDOjhkPmAYew43HcOM1PPgML37Dh9/wETD8BMzgH8MMYJoGSpkoZcpKL6LO+u0Q/JIXiHYYoopJy7ioEYvWH8TucMn6u6LWS0pK4rLLLuOyyy6LdiiijpF6TtRW+/bt47TTTiux/7TTTuP333+PQkTHxmlz0jChMft9XlToP6UwiyZvVShM07SOmZgoM5iEm5glhiMpVJmTphbfH7rekWU1tLAJWbWi/458HSxW7JhW/JjM61LrFP09UUXj/FSx7dC+wz9UuT9LK1v6ewb/XoT+nhUvu/BHHafDw7ySv8qiDpNkXAghhBDiOJafn1/mMY/HU4ORVA27bqdhTEMM/ejnZwhLrMpLukpLwI44ZirT2lZKWQm/te+IY9YDAVX6w4Ej49S0UpL/UJyl5PDFk//i20c+JAg9HLCOVfXDgVqWzJYserhMaQ9jQt+7XtSROLQdKqujo+nh35uu6aWeq+u6dW6o/JHXs96X8P2hck79AA5duqkfbyQZF0IIIYQ4jrVv357XXnuNSy+9NGz/66+/Trt27aIUVXSFJUK1pFG6eOIO4UlnaccqejgABJexwwRV1GOgtGNg9R4IbZf2gCCUtDr8dtyBwnJ7FED5yaz1XyWS2SN7FFQmmT0ysS1RVis9Aa5NdE2rlXGJYyPJuBBCCCHEcWzq1KmMHz+eVatWWcn3d999h9/vZ+7cuVGOToRYSWMtybdCDwCOfJ3SMIU8MzhRZV1KZoWojSQZF0IIIYQ4jjVq1Ihly5bx+eef88svvwDQp08fzjnnnChHJmqz8G7rh/fbbXbsuqQQQlQF+U0SNeKKMxvSoEEDwBvtUIQQolpIPSdqu7PPPpuzzz472mEIIY7CTe0SaJCUFO0wRBWTZFzUiDbpTlJS4snLk5tUcXxZt24ds2bNwjRNRo4cybhx40qUWbNmDXPnzkXTNNq0acPs2bMBaNu2LaeeeioAmZmZzJ8/v0ZjF1VL6jkhhBDVpWOag5RG8eyPdiCiSkkyLmrEjzk+GhQW0jQ+2pEIUXUMw2DmzJksXryY9PR0RowYQd++fWnVqpVVJjs7mwULFvDKK6+QlJTE/v2H/xmNjY3lzTffjEboohpIPSeEEKK6bN7vp0GgkBYnxUU7FFGF9GgHIOqHpV8d4rmPc6IdhhBVavPmzbRo0YJmzZrhdDoZPHgwa9euDSvz2muvMXr0aJKKupalpaVFI1RRA6SeE0IIUV3mfe/iia/2RjsMUcUkGRdCiKOUk5NDRkaGtZ2enk5OTngylp2dzW+//cbll1/OpZdeyrp166xjXq+XSy65hEsvvZT333+/xuIWQgghhBDRJ93UhRCiGhmGwfbt23nxxRfZvXs3V1xxBatWraJhw4b897//JT09nZ07d3L11Vdz6qmn0rx58zKvZbPZKmxZ9wQ8eAo8JKYkVvVHERWwOw6gaRopKSnRDqXeMVVwveS0FOl5IoQQou6QZFwIIY5Seno6u3fvtrZzcnJIT08vUaZTp044HA6aNWtGy5Ytyc7OpmPHjlbZZs2a0b17d7Zs2VJuMm4YRtiY89J4Ah4Mu0Heobxj+GSisnyGD6/Pi91uZ9eeXTh0Bw7dIWvt1hBTmSQ0TKjw9yMzM7OGIhJCCCEqJt3UhRDiKHXo0IHs7Gx27tyJz+cjKyuLvn37hpXp378/X375JQC5ublkZ2fTrFkzDh48iM/ns/Zv3LgxbOI3Ufv5DB8uvwuX34XD5sBpcxJrj6VJXBMcNgeFgUIK/YW4A24CZiDa4QohhBCilpGWcVEjxpyTVLT+rifaoQhRZex2O9OnT2fs2LEYhsHw4cNp3bo1c+bMoX379vTr149evXrx6aefMmjQIGw2G5MmTSIlJYWNGzcyY8YMNE1DKcX1118vyXgd4Df8+EwfCkW8PZ60uDRibbHYdBt3/DWJpKRkGjh9NIhpgKlMvIYXt99Nvj8frz+45Jldt+PUndJqLoQQImJ/75hIg+TkaIchqpimlFLRDqIq+Hy+CrunBcwAB/WD+F3+GopKFJeSkkJennSdjQZHgoMUlYKuld8ZRrpw1m6R1HOegAeX3SX1XBUqnoDH2mJJciYR54jDrpd8np2Wllbm/yO/6cdn+Mj35VPoL0Sh0DUdh+4o9VoicqFu6klmUrnlpI6r/SKp57TCQlLdbvL8Us9Fg9zPRYnfT0qjRuyPK39pM6nn6hb511/UiG9+95J4sIBTyr9PEkKIWiGUOIcS8CZxTcpMwEO+3HGIhgegTXLpx0PjyBMcCZjKxGf4cAfcFPgLKPAXoKFJq7kQQohSfbnHR6LHRZvWss748USScVEjXt+Uj93h5t7zk6MdihBClCpgBvCZPkzTJMYeQ+O4xsQ54nDojojOX/LlbhyO/cy5+KQKy+qaTqw9llh7LCmxKQTMAF7DS4GvAJffhUKhoeG0OaXVXAghBIt/LMTu8DOndaNohyKqkPwLL4QQot46MgFvFNuoUgl4VbHrduy6nQRHAkopvIYXj+Eh35dvJeehlvWKhpsIIYQQom6o1mR83bp1zJo1C9M0GTlyJOPGjQs7/scff3DXXXeRn5+PYRhMnDiRPn36sGvXLgYNGsRJJwVbFzp16sTMmTOrM1QhhBD1hGEaeA0vJiYO3UFqbCrx9nicNme0QwNA0zSr1Tw5Jjn4wMDwBbuz+wowMdHRcdgcNf7QQNQ/Fd3LLV68mNdffx2bzUZqaioPPvggTZs2BYL3edOmTePPP/9E0zQWLFjAiSeeGI2PIYQQtVK1JeOGYTBz5kwWL15Meno6I0aMoG/fvmGzBc+bN4+BAwcyatQotm7dyrhx4/jggw8AaN68OW+++WZ1hSeEEKIeKZGAx6USZ48jxhYT7dAqFGo1j3fE0ziuMT4zONY835dvjTW3aTacNqe0mosqFcm9XNu2bVmxYgVxcXG8/PLLPPbYYzz55JMA3HXXXdx444306NEDl8uFrsvfTyGEKK7akvHNmzfTokULmjVrBsDgwYNZu3ZtWAWuaRoFBQUA5Ofn06RJk+oKRwghRD1jmAY+04ehDByag5TYFOId8XUiAS+LpmnE2GKIscWEtZq7/C4K/AWYykTTNKtLuxDHIpJ7ubPPPtt63blzZ9566y0Atm7dSiAQoEePHgAkJCTUYORCCFE3VFsynpOTQ0ZGhrWdnp7O5s2bw8qMHz+eMWPGsHTpUtxuN4sXL7aO7dq1i6FDh5KYmMhtt91Gt27dqitUUQNu6plMw6SGQGG0QxFCHMdCa3ubysSm2WjobEiCI4EYW0y1z1B+V7/mJCcnA55qfZ/iireaN1KN8Jk+vAEvh3yHcPldoMCmS6u5ODqR3MsVt3z5cnr37g1AdnY2DRs2ZPz48ezatYtzzjmHiRMnYrPZqj1uIY5Hk7sk0jAlJdphiCoW1QncsrKyGDZsGNdddx2bNm1i0qRJrF69miZNmvDf//6XlJQUvvvuO2655RaysrJITEws81o2m420tLRy3y9gBnAdcpGYUvZ1RPVISQG73U4gUHdbpOoyj+EhLSlNbsbFcal4Aq5reo0m4MW1SIklLS2B/ftrLhkvrnirecOYhsGu+aaXQl8hBf4CAioQXNdcc+CwSau5qFpvvvkm3333HUuXLgUgEAiwYcMGVq5cSWZmJn//+9954403GDlyZLnXieR+jthY7Dk5pJRzXyiqj91uJ0WSwhqXkpiI3ekkUNHvh6hTqi0ZT09PZ/fu3dZ2Tk4O6enpYWWWL1/OwoULAejSpQter5e8vDzS0tJwOoMT6bRv357mzZvz22+/0aFDhzLfzzAM9u/fX25MATNAQA+QdyjvaD+WOEpfbfeQmJhI27RAtEOplxwJDvbv319hMp6ZmVlDEQlxbEIzjhvKQEMLJuDOBGJtsVFbo/vjXw/QcK9Jp8a146GXTbcRr8cTb48nTaXhN/14AodnaNfQ0DQNp+7EpktrpSgpkns5gM8++4z58+ezdOlS6/4tIyODtm3bWl3c+/XrxzfffFPhe0ZyP6cVFpIaCJCXJ/dz0ZCSkiLffRR8vKOAxIYN6eQsf7JRuZerW6rtjqFDhw5kZ2ezc+dOfD4fWVlZ9O3bN6xMZmYm69evB2Dbtm14vV5SU1PJzc3FMAwAdu7cSXZ2tlWZi7rpzW8LeHXDvmiHIYSow5RSeAIeXH4X7oCbREciJySewElJJ9EovhFx9rioJeIAr2zcw/OfbY/a+5dH04JrljeMaUjTBk1p2bAlGYkZNHA2CPYa87tw+V34DT9KqWiHK2qJSO7ltmzZwvTp05k3b15Yi3aHDh04dOgQubm5AHzxxRdhY82FEJXz8i9unt+cG+0wRBWrtpZxu/3/27v36CbK/H/g75lJ0qb3CzTteqqAVFC5rutXPVLEcqdU7qtoXRWwrsICIncQv7LKRdEViz8WxNuisstBRAF3OUtRCoiIiJQKCiqVIrb4LaWXtLnNPL8/QoamLaVAm6Tp+8XhtMnMJM/MpJ/kk88zz2PAggULMGHCBKiqilGjRiElJQXLly9Hly5d0LdvX8yePRvz58/H22+/DUmSsGTJEkiShP379+PVV1+FwWCALMt49tlnz1+HR0RErYkQAg7NAZfqAiQg0hSJCFMEQpVQXnZxFWpWzduY28Chuq81r3BWoMrlHttDlmRWzVu5xnyWe+GFF1BVVYUpU6YAcBda/v73v0NRFMyaNQsPPfQQAODmm2++ZBd1CnCqCrhcQHU14HQCsgxwDACiqyKJIPkK3OFwNKqbeplcBqfV6aNWkcf8Lf8Hg9GA/x0Y4++mtErGcCNiRSy7qbdwjYlzNpcNVoO1Rce5mgm4JEmIMEW0iAT8iQ3HYDQasXxYe3835ap4rsGvclah0lEJp+b0GqHdn70PLkYTGsKjwhGtRTe4HmNc4GtMnJOqqhBXXY1SZ8uNcwHP5QJcLkiqCgFAAgCDAVpoKOISEnC2qAiywwG4XBeWAxCyDBgMTNSbweM5v8FgNGL5Hzs3uB7jXMvi1wHciOjKCCEgIKAJzfv38z9ri5fjIamB9wGayEMIAafmhFNzf7gON4ajrbktQg2BnYAHI1mSYTaYYTaYEW+O16vmla5KVDlZNScKKkLUTbwlCcJkgoiIgDCbIRQFMBovJNfx8RCSBBUANE2vmEuqCjgcgN3uTtRttrqJuqJc+E9ETMaJ/KWxCbUECRo0SPBOpg2S+zIOWZJhkA1QZAUG2QAZMhRZgSRJkCBBlmQkRCegrLTM17tIdEkO1QGH5oAECeHGcLQxt0GIEsIkL4CYFBNMigmRIZF61bzaWY0KZwWqHdUBXzUnovM0zZ00u84PpisEIMsQISEQ4eEQoaEQBoM78W7s37Isu/8bjajZ1Vb1PL4n0dc0wG4H7HZITickm01/fgjBRJ1aLSbj5BNT+8QiOjoaUCv93ZQmVTuh1lA3sZbO/xMQEEJ4fVj1JNSKrECRlHoTahmy+6cke/1+OQwy/9QpcDhVJxyaAwLCPdK3OR6hSmiLT8CfGdjOPd2Py+rvpjSbmlXzOHMcnJoTDtWhj9DuWccoGxl3iPypRrUbgDvxNRqhhYZCxMRAGI0Xqt3N9SWaJLmfw5Ooh4e7m+Jpj8sFqKq7jXY74HRCstvdibpneybquv/9QySi4+L83QxqYnynJJ9oE6EgNsqIQJwJQ4gLibMnofZUpvUKtTjfbatWQi1JEhQokGUZBsUARVL0SrVBMrir0/Uk1LIks4JErYpTdcKu2SFBQqgSigRzAsxGc1AlbJZIE+KjQ1FSErzJeG2eini4MRya0OBQHah2uavmlc5KSJBgkA0wySbGPKLmUKv67OkWrnczr1ntDqRE9lKJeu2u7w6HO1G3293LJQnQNHcXekVxV9gNwfN+Uh9LmILYCCMaHlGBWprgftVSwNj9YzXCI2T0rDs9aZO43ITafVPo3bhlyI1KqD1JNBNq8sjNzcXzzz8PTdMwZswYZGVl1Vnnk08+wYoVKyBJEjp37oyXXnpJX1ZZWYkhQ4agX79+WLBggS+b3uw8VVMBgVAlFBazJegS8Jq2HzuLiAgnbv+d0d9N8QtZkhFqCEWoIRSxobH6+a90VMLqtOox16SYgvY1QNSsanYzF8K7m3l09IXE2zOAWkslSe59MBgunag7ne6u73Y7pKoq9/LzhKcLvSdhb+Gf2f57yobwsnLc3sXs76ZQE+K7IfnEf45aYTDa0bOB0dQ9CbUGDRDQE2pPt28Aenfv2mRJ1v8bFHcSLUvurt6e3yFBT6JlSdYTcSbUdKVUVcXChQvx1ltvwWKxYPTo0UhLS/OaS7egoACrV6/GunXrEB0dXWeU4FdeeQW33nqrr5vebDyDsGmahhBDCNqa28JsNMMoB3+CujHv/2A0luH2Fj6aelOpWTUXQsCu2mFTbahwuKvmnnVYNSeqR80u3IA7yTQYoIWEQERFQZhM7sqywdDik8zLUjtRP69Ooq5p+mByksMBqbraXUmX3CPwtMREfeNPNhiMKm7v0kyVLfILJuPUbFRN1RNqTWhQNRVWp7XehFpA6NdMy5ChKO4kWpHOdwE/n1DXHJSMCTX5W15eHq677jokJycDANLT05GTk+OVjK9fvx4PPPCAe8wEAPHx8fqy/Px8lJSUIDU1Ffn5+b5tfBNyaS44NIeegLcJbdNqEnBqHEmS9Kp5TEgMXJoLdtUOq9OKSkclNGiQIcOoGPm6odaldjdzIS50Mw8Lc1e7a17fTRdXO1EPCwPQQKLu6fpeK1GHJF3o/t5CEnVquZiM02UTQkAVqp5ke7qH1yRBgiK5ByMLNYTCIFthUoxICk+qk1B7kmom1NTSFBcXIzExUb9tsViQl5fntU5BQQEA4L777oOmaZg0aRJ69+4NTdOwdOlSvPjii/j888992ewm4dJccKgOaNBgUkyIC41DmCEMJsXk76ZRC2CQDTDIBn0Ku5pVc89AcIqkwKSYOLUdBY9a3cy9phGLivK+vrsldzMPRI1J1D09ERwO92ByNps7UfecK89lAUzUqQkxGScvtavZtees9lSwDbJBv+7PJLt/SpI7Afdcc+01arhcCkU2IMwY5utdIvIrVVXx888/Y+3atSgqKkJmZiY2b96Mjz/+GL179/ZK5i9FURSvynp9bC4bbJU2RMRGXG3T61A1FTaXDUK4R0GPCYlBuCmcCfh5RqN7aq9LnSNqmEtzuec1d1SiwlEBTWiQJAkm2QSjUn/V3HOJU3wsjz0FCE8VtuY0YoriHs28NXczD0QNJeqA9zXqLpe767vN5h71vcageXpF3TOYHM8rNQKT8VbiyqrZBhhlo3vqrfMJtucnEbkr4UVFRfrt4uJiWCyWOut0794dRqMRycnJaNeuHQoKCnDw4EEcOHAA69atg9VqhdPpRFhYGKZPn37R51NVtc4157XZXDaoBhWl5U0zdYGqqXBoDqhChVEyIiokCuHGcISoIdCqNFRUVTTJ8wQDp9MJo9F4yXNEjWOAATEiBg7NAbvLjnOOc7CpNkhCgiJ7V801oSE8KvySxz4pKckXTafWpGY3c1W9cE2y0ejuZh4ScqGbeZCP9h20zlfB61yjDtSfqHumZ/NcdiBJ7kTdc406E3WqgVEhCDRXNbspLUrvgNjYWAgbP7hT8OjatSsKCgpQWFgIi8WCrVu3eo2UDgD9+vXD1q1bMWrUKJw9exYFBQVITk72Wm/jxo3Iz89vMBH3JU1osKt2PQGPNkW7K+AcaKtBjHNNT5IkhCghCFFCEBUSBVVTYVftqHJWocJ5oWpukPhxhnxA07yuO/aaRiwyEsJsZjfz1qYRiTpU1d1DomaiXuOLGwAXur43kKgvvi0K0fFx9QxjTC0Z370C2JVUs42K0T3YWYBVs2PMBsSFm1Bi82sziJqUwWDAggULMGHCBKiqilGjRiElJQXLly9Hly5d0LdvX6SmpmLPnj0YMmQIFEXBzJkzERsb6++m1+FJwDWhQZEURJnOV8CVECbgjcQ41/wUWUGYHIYwYxjiRbxeNa9wVLgvl9Au/RhEjdJAN3NERroTcE/izRhJ9fEk2LiQoF80UfcMJle76zsuJOoxJgmxoQbOMx5kJCFEUHzB4nA4Ltk9zaW5UCaXwWl1+qhVF3c51WyjbPRLNbspbT1SgoiICNx1bYi/m9IqxcfHN6rrLLtwBrbGxDmbywarwdqoOFczAZclGZGmSIQbwxGqhLaIuBJoGOf8qzFxjjEu8DUmzklVVYirrkaps4k+z9XsZo7zSZDB4E68zWZ2M6+lsZ8p6AqdH0xO/zLofKK+9YcKhMXF4a6uCQ1uzjjXsjCqNLGmqGZ7kmx/V7Ob0tYjJTAay3HXtZx/l8ifPPM9q0KFBMldATcxAW8KjHNEAa729d2oMZp5RIS7m7micBox8i9PRd1k8qqob957DMZzVtzV1Z+No6bGZPwytIRrs4mIavMk4J4vByNNkYgwRSBUCQ2qL/2IiHQ1pxED3Im4LLsHVAsP955GjJ/JiMhPmIyD1WwiCj5CCDg0B1yqC5IkIcIUwQSciIJTjWo3AHfibTS6pxGLibnQzZzzQhNRgGl1ybgQAlan9cJtVrOJKMhoQkOVqwrhxnC0NbdFqIEJOBEFGZcLsFovjGYeEeFd7WY3cyJqAVpVMq5ICq6JugZhahir2UQUlEyKCddGX4tKUQlF5odRIgo+IiQEiIuDVl7uHlSN04gRUQvVqpJxT1dNu8Hu76a0Oi8P64i4uDhUVZzzd1OIgposyQgzhqFarvZ3U1odxjkiH1EUIDwcsHEeQWo9+B4TnPhVIvlEqFGG2cQqHREFL8Y5IiJqLnyPCU6tqjJO/vPBod8QHlGFQdeH+bspRETNgnGOiIiaC99jghMr4+QTOcdL8e/8Yn83g4io2TDOERFRc+F7THBq1mQ8NzcXAwcORP/+/bF69eo6y0+fPo0HH3wQw4cPR0ZGBnbu3Flnec+ePfHGG280ZzOJiIiIiIiIfKrZuqmrqoqFCxfirbfegsViwejRo5GWloaOHTvq66xcuRKDBw/G/fffjx9++AFZWVnYsWOHvnzJkiVITU1triYSERERERER+UWzVcbz8vJw3XXXITk5GSaTCenp6cjJyfFaR5IkVFZWAgAqKiqQkJCgL9u+fTuuueYapKSkNFcTiYiIiIiIiPyi2ZLx4uJiJCYm6rctFguKi72vc5g0aRI2b96M3r17IysrC/PnzwcAWK1WvP7665g0aVJzNY+IiIiIiIjIb/w6mvrWrVsxYsQIjBs3DgcPHsTMmTOxZcsWrFixAg899BDCw8Mb/ViKoiA+Pv6S6xkMhkatR03rX4/dAYPBAJfL5e+mtEp83RM1v/83+gbEx8ejpKTE300hIqIgw/eY4NRsybjFYkFRUZF+u7i4GBaLxWudDRs2YM2aNQCAnj17wm63o7S0FIcOHcK2bduwbNkylJeXQ5ZlhISEIDMz86LPp6pqo16cfBH7D4+9/zT22CclJfmgNURERERE1GzJeNeuXVFQUIDCwkJYLBZs3boVL730ktc6SUlJ2Lt3L0aOHIkff/wRdrsdcXFxeP/99/V1srOzERYW1mAiTkRERERERNSSNFsybjAYsGDBAkyYMAGqqmLUqFFISUnB8uXL0aVLF/Tt2xezZ8/G/Pnz8fbbb0OSJCxZsgSSJDVXk4iImlxubi6ef/55aJqGMWPGICsrq846n3zyCVasWAFJktC5c2e89NJL+OWXXzBp0iRomgaXy4XMzEyMHTvWD3tARERERP4gCSGEvxvRFBwOB7upBzgee/9hN/XmoaoqBg4c6DWF48svv+w1hWNBQQGmTp2Kd955B9HR0SgpKUF8fDwcDgcAwGQywWq1IiMjA+vWratzOU9NjHOBj8fefxpz7BnjAh/jXODjsfcfxrng02yjqRMRBbvGTOG4fv16PPDAA4iOjgYAfSA9k8kEk8kEwP3hU9M03zaeiIiIiPyKyTgR0RVqzBSOBQUFOHHiBO677z788Y9/RG5urr7s119/RUZGBvr06YNHH320wao4EREREQUXv05tRkQU7FRVxc8//4y1a9eiqKgImZmZ2Lx5M6KiopCUlITNmzejuLgYEydOxMCBA9GmTZuLPhancAx8PPb+w2NPREQtDZNxIqIr1JgpHC0WC7p37w6j0Yjk5GS0a9cOBQUF6Natm9c6KSkp+OqrrzBo0KCLPh+ncAx8PPb+w2spiYiopWE3dSKiK1RzCkeHw4GtW7ciLS3Na51+/frhyy+/BACcPXsWBQUFSE5ORlFREWw2GwCgrKwMX3/9Ndq3b+/zfSAiIiIi/wia0dSJiPxh586dWLRokT6F4+OPP+41haMQAkuWLMGuXbugKAr+/Oc/Iz09HXv27NGncxRCIDMzE/fee6+/d4eIiIiIfITJOBEREREREZGPsZs6ERERERERkY8xGSciIiIiIiLyMSbjRERERERERD7GZJyIiIiIiIjIx5iMExEREREREflYwCbj5eXlmDx5MgYNGoTBgwfj4MGD+rI333wTnTp1wtmzZ/X7nE4nRowYod9WVRXDhw/HY489pt9XWFiIMWPGoH///pg6dSocDoe+7MyZMxg3bhwA4MMPP8SAAQMwYMAAfPjhh/W2b+nSpRg0aBAyMjIwceJElJeXN9m++9qcOXNwxx13YOjQofp9F9s/p9OJWbNmISMjA4MHD8aqVau8HmvBggU4cOCAfrv2uRJC4LnnnkP//v2RkZGBb7/91mv7CRMmoKioqMFz5bFnzx6MHDkSGRkZGDlyJPbu3dtkx8RXfv31Vzz44IMYMmQI0tPT8c477wAAsrOzkZqaimHDhmHYsGHYuXOnvs13332He++9F+np6cjIyIDdbteXrV69Gh9//LF+e9u2bejUqRMOHz6s37dq1Sr0798fAwcOxK5du7za4zl/586dwyOPPIIBAwbgkUceQVlZWZ22Hz161Ksdn3zySZMdl9aCcc53GOf8h3Gu9WKM8y3GOf9gjKOrIgLUzJkzxfr164UQQtjtdlFWViaEEOL06dNi3Lhxok+fPqKkpERff+/evWLhwoX67TfffFNMmzZNZGVl6fdNnjxZbNmyRQghxNNPPy3ee+89fdmGDRvEG2+8IUpLS0VaWpooLS0V586dE2lpaeLcuXN12rdr1y7hdDqFEEK88MIL4oUXXmjCvfetL7/8UuTn54v09HT9vovt38cffyymTp0qhBCiqqpK3H333aKwsFDf7p577hEul0sIUf+5+uyzz8T48eOFpmni4MGDYvTo0fq21dXVYtSoUUKIhs+Vx7fffiuKioqEEEJ8//33olevXk1zQHyouLhY5OfnCyGEqKioEAMGDBDHjx8Xr776qlizZk2d9Z1Opxg6dKg4evSoEEKIs2fP6sdbCCEyMzP1Y11RUSHuv/9+MWbMGJGXlyeEEOL48eMiIyND2O12cfLkSdG3b1+v7T3nb+nSpWLVqlVCCCFWrVpV7+v7p59+EidOnBBCCFFUVCTuvPNO/e+UGodxzncY5/yHca71YozzLcY5/2CMo6sRkJXxiooK7N+/H6NHjwYAmEwmREVFAQAWL16MGTNmQJIkr2127dqF3r17AwCKiorw2Wef6dsD7m/wvvjiCwwcOBAAMGLECOTk5NTZfvfu3bjzzjsRExOD6Oho3HnnnXW+cQKAXr16wWAwAAB69OiBoqKiJjwCvnXrrbciOjra676L7Z8kSaiurobL5YLNZoPRaERERAQA4Mcff0S7du2gKAqA+s9VTk4Ohg8fDkmS0KNHD5SXl+PMmTMAgH379uF//ud/LnmuPG666SZYLBYAQEpKCux2e73fuAayhIQE3HzzzQCAiIgIdOjQAcXFxRddf8+ePejUqRM6d+4MAIiNjdWPd2VlJZxOJ+Li4gAAy5cvx6OPPoqQkBB9+5ycHKSnp8NkMiE5ORnXXXcd8vLyAHifP895AoDhw4dj+/btddrSvn17tGvXDgBgsVgQFxfnVeGghjHO+RbjnP8wzrVOjHG+xzjnH4xxdDUCMhk/deoU4uLiMGfOHAwfPhzz5s1DVVUVtm/fjoSEBP3FW5PnDx8AFi1ahBkzZkCWL+xeaWkpoqKi9ICUmJio/6GoqooTJ06gY8eOKC4uRmJior6dxWJp8A8KAD744AP9zSMY1dy/gQMHwmw2o1evXrj77rsxbtw4xMTEAAByc3ORmpoKABc9V7WPb83zsGvXLqSmpjZ4ri5m27ZtuOmmm2AymZpkn/3h1KlTOHr0KLp37w4AeO+995CRkYE5c+boXYtOnDgBSZIwfvx4jBgxAq+//rq+/eeff4477rgDAPDtt9+iqKgIffr08XqOhl7fNc9fSUkJEhISAABt27ZFSUlJg23Py8uD0+nEtddeexVHoHVhnAssjHO+wTjXejDGBR7GuebHGEeXKyCTcZfLhSNHjmDs2LHYtGkTzGYzsrOzsWrVKkyZMqXO+sXFxYiOjobZbMann36KuLg4dOnSpdHPd+jQIf2P5nKtXLkSiqLgnnvuuaLtA13t/cvLy4Msy9i1axdycnLw5ptvorCwEACwe/dupKamorq6+qLnqiFff/01brnllstu4/Hjx7Fs2TIsXLjwsrcNFFarFZMnT8bcuXMRERGBsWPH4r///S8++ugjJCQkYMmSJQDcHzYOHDiAF198Ee+//z62b9+uX1vlqQhomoYlS5Zg1qxZl9UGz/mrTZKkOtWLms6cOYMZM2Zg8eLFXh+aqGGMc4GDcc43GOdaF8a4wMI41/wY4+hKBOTRTkxMRGJioh5UBw0ahCNHjuDUqVMYNmwY0tLSUFRUhJEjR+K3337z+hbo66+/xo4dO5CWloZp06bhiy++wPTp0xEbG4vy8nK4XC4A7u5Pni4xNbe3WCxe3ZSKi4v19WrbuHEjPvvsMyxbtqzBF3hLVd/+bdmyBampqTAajYiPj8fvf/97HD58GNXV1SgvL4fFYsHJkycveq5qH1/PeSgsLERiYiJMJlOD56q2oqIiTJo0CUuXLm2x3+Q5nU5MnjwZGRkZGDBgAACgTZs2UBQFsixjzJgx+qAdiYmJuPXWWxEXFwez2YzevXvrg6bk5eWhW7dusFqtOHbsGP70pz8hLS0N33zzDR5//HEcPnz4oq/vmucPAOLj4/XuZmfOnNG7S9VWWVmJxx57DE8++SR69OjRXIcoKDHOBQbGOd9gnGt9GOMCB+Nc82OMoysVkMl427ZtkZiYiJ9++gkAsHfvXtx0003Yu3cvduzYgR07diAxMREbN25E27Zt9e4wAPDUU08hNzcXO3bswMsvv4zbb79dDz633XYbtm3bBsA9ymZaWhoA4IsvvtC7hPTq1Qu7d+9GWVkZysrKsHv3bvTq1atOG3Nzc7FmzRqsXLkSZrPZF4fFpy62f0lJSdi3bx8AoKqqCocOHUKHDh2wb98+3HbbbQCATp06XfRcpaWlYdOmTRBC4JtvvkFkZCQSEhK83kQbOlc1lZeXIysrC0899dQVfQMbCIQQmDdvHjp06IBHHnlEv98TPAF3F7GUlBQA7tfnsWPH9Ou89u/fj44dO+L48ePo0KEDFEVBZGQk9u3bpx//Hj16YOXKlejatSvS0tKwdetWOBwOFBYWoqCgAN26dfM6fwD08wQAmzZtQt++feu03eFwYOLEiRg2bBgGDRrUTEcoeDHO+R/jnG8wzrVOjHGBgXGu+THG0dUw+LsBF/P0009j+vTpcDqdSE5OxuLFi+tdT1VVnDx5Etdff/0lH3PGjBl48skn8corr+DGG2/EmDFjcPbsWZhMJn3QipiYGDzxxBP6gCETJ07Ur6GZN28e7rvvPnTt2hV//etf4XA49D+67t27t9huNdOmTcOXX36J0tJS9O7dG3/5y1+wevXqevfvgQcewJw5c5Ceng4hBEaOHInOnTtj/fr1+gAdDbnrrruwc+dO9O/fH2azGYsWLQLg7pYzf/58fb36zhXgHrQiPz8fU6ZMwbvvvouTJ0/itddew2uvvQbAPfVGfHx8Ux+iZnPgwAF89NFHuOGGGzBs2DAA7vOxZcsWfPfddwCAa665Rn9tRUdH4+GHH8bo0aMhSRJ69+6NPn364I033qi3W1JtKSkpGDx4MIYMGQJFUbBgwQIoioLc3Fyv85eVlYWpU6diw4YN+N3vfodXXnkFAHD48GH885//xPPPP49///vf+Oqrr3Du3Dl92pglS5bgxhtvbMpDFNQY53yHcc5/GOdaL8Y432Kc8w/GOLoqfhjBvUnt379fPP3001e8/aZNm/Rh/+nKDR8+XDgcjiva1m63ixEjRjRxi1qXhx9+WBQXF1/x9ldz/qj5Mc4FBsY5/2KcC16McYGDcc5/GONaJ0kIIfz9hQARERERERFRaxKQ14wTERERERERBTMm40REREREREQ+xmSciIiIiIiIyMeYjBMRERERERH5GJNxAgCcOnUKQ4cOvaxtNm7ciOLi4kuuc6XThKxbt06fH5GI6GoxzhFRMGOMI2p5AnaecQp8H374IVJSUmCxWJrl8ceOHdssj0tE1FiMc0QUzBjjiPyLyTjpXC4XnnrqKRw5cgQpKSlYunQpzGYzVqxYgU8//RR2ux09e/bEwoULsW3bNuTn52P69OkIDQ3Fv/71Lxw7dgyLFi1CVVUVTCYT3n77bQDAmTNnMH78eBQWFqJfv36YOXNmnedetmwZduzYAUVR0KtXL8yaNQvZ2dkICwvD0KFDkZWVpa977NgxbN++HWazGc888wxOnz4NAJg7dy5uueUWnxwrImqZGOeIKJgxxhG1MP6e6JwCQ2FhobjhhhvEV199JYQQYvbs2WLNmjVCCCFKS0v19aZPny5ycnKEEEJkZmaKvLw8IYQQdrtdpKWliUOHDgkhhKioqBBOp1N88MEHIi0tTZSXlwubzSb69OkjTp8+7fXcZ8+eFQMGDBCapgkhhCgrKxNCCPHqq6/qbfB49913xeTJk4UQQkybNk3s379fCCHEL7/8IgYNGtRkx4OIgg/jHBEFM8Y4opaHlXHSJSUl6d9G3nPPPVi7di3Gjx+Pffv2Yc2aNbDZbDh37hxSUlKQlpbmte2JEyfQtm1bdOvWDQAQERGhL7vjjjsQGRkJALj++uvxyy+/ICkpSV8eGRmJkJAQzJ07F3fffTf69OlTb/sOHDiA9evX4/333wcAfP755/jhhx/05ZWVlbBarQgPD7/6g0FEQYlxjoiCGWMcUcvCZJx0kiTVuW232/Hss8/igw8+QFJSErKzs2G32y/rcU0mk/67oihQVdVrucFgwIYNG7B371785z//wbvvvot//OMfXuucOXMG8+bNw8qVK/UArWka1q9fj5CQkMtqDxG1XoxzRBTMGOOIWhaOpk6606dP4+DBgwCALVu24JZbbtGDdWxsLKxWK7Zt26avHx4eDqvVCgBo3749fvvtN+Tl5QFwf7Ppcrka9bxWqxUVFRW46667MHfuXHz//fdey51OJ6ZMmYLp06ejffv2+v29evXC2rVr9dtHjx69gr0motaEcY6IghljHFHLwso46dq3b4/33nsPc+fORceOHTF27FiYzWaMGTMGQ4cORZs2bdC1a1d9/REjRuCZZ57RB/3429/+hueeew42mw2hoaF46623GvW8VqsVTzzxhP5mMXv2bK/lBw8eRH5+PrKzs5GdnQ0AWL16NebNm4eFCxciIyMDqqriD3/4wxVPvUFErQPjHBEFM8Y4opZFEkIIfzeCiIiIiIiIqDVhN3UiIiIiIiIiH2MyTkRERERERORjTMaJiIiIiIiIfIzJOBEREREREZGPMRknIiIiIiIi8jEm40REREREREQ+xmSciIiIiIiIyMeYjBMRERERERH52P8HOVTUgoVJu/sAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1080x288 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "performances_df_nn_subset = performances_df_nn[performances_df_nn['Parameters'].apply(lambda x:x['clf__lr']== 0.001 and x['clf__module__hidden_size']==500 and x['clf__module__num_layers']==2 and x['clf__module__p']==0.2 and x['clf__max_epochs']==40).values]\n",
    "summary_performances_nn_subset=get_summary_performances(performances_df_nn_subset, parameter_column_name=\"Parameters summary\")\n",
    "indexes_summary = summary_performances_nn_subset.index.values\n",
    "indexes_summary[0] = 'Best estimated parameters'\n",
    "summary_performances_nn_subset.rename(index = dict(zip(np.arange(len(indexes_summary)),indexes_summary)))\n",
    "get_performances_plots(performances_df_nn_subset, \n",
    "                       performance_metrics_list=['AUC ROC', 'Average precision', 'Card Precision@100'], \n",
    "                       expe_type_list=['Test','Validation'], expe_type_color_list=['#008000','#FF0000'],\n",
    "                       parameter_name=\"batch size\",\n",
    "                       summary_performances=summary_performances_nn_subset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With this higher number of epochs, the optimal batch size is now globally higher. Let us now do the contrary, i.e. fix the batch size to some value (e.g. 64) and visualize the impact of the number of epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+MAAAEoCAYAAAAzNCCOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAACt7klEQVR4nOzdd3wU1frH8c/MtuxueoBQpKigIF0Q9NKkXQVEqdcr2EFs+LMrIIKi2PGKongRBBUVFbwoxApeQRQVLgiKioL0EiA9m60z8/tjkyWbTkk25Xn7yivZmdnZsyuZ7HfPOc9RDMMwEEIIIYQQQgghRJVRI90AIYQQQgghhBCirpEwLoQQQgghhBBCVDEJ40IIIYQQQgghRBWTMC6EEEIIIYQQQlQxCeNCCCGEEEIIIUQVkzAuhBBCCCGEEEJUMQnjQgghRC1w7rnn8tlnn1Xo2EmTJnHzzTdXcouEECfjsssu46WXXop0M4r58MMP6dy5c4WPP5FrkhB1lSLrjNdN27ZtY9SoUXTs2JElS5aE7du/fz/9+/dn6dKltG/fPmzfNddcQ6tWrZg2bVpo22+//ca///1vNmzYQFZWFo0aNaJLly7ccMMNnHvuuSU+/qRJk/jPf/4DgMlkokGDBvTp04d77rmHuLi4sGO3bNnC3Llz2bRpE3l5eZxxxhlcdtll3HTTTdhstrBjT6YtQojKU9a1RpxeR48eJS4uDqvVWu6xOTk5GIZBbGxsFbRMiJrt2LFjvPrqq3z99dccPnyYhIQEzj33XK655hr69Olz2h/vsssu45JLLuGOO+4ocf+HH37I5MmTQ7fr169Ply5duO+++2jatOlpb08Bj8eDy+UiKSmpQsefyDXpRPn9fj766CM+/fRT/vzzT/x+P02aNKFv375cc801xa5tGzZsYMGCBWzbto0jR47w5JNPMmLEiLBjDMNgzpw5vPfee2RnZ9OxY0emTZtGq1atQsdkZWXx+OOP89VXXwHQr18/Hn74YbmWipMmPeN11AcffMCYMWP4888/2blz50mf57///S+jR48mLy+PZ555hk8//ZTnn3+e+vXrM2vWrDLv+7e//Y1169bx1Vdf8fjjj/Pf//6XRx99NOyY1atXM3bsWBISEli4cCGff/45EydO5L333uPGG2/E5/OdlrYIISrH6brWVJTf76/0xzjdCl/HTkX9+vUr/KY3JiZG3jwKUQH79+9n+PDhrFu3jnvuuYePP/6YRYsWcfHFFzN9+vSTPq+u62iadtL3t9vtrFu3jm+++YbnnnuO33//ndtuu63Uc56Oa2NUVFSFgzic2DXpROzfv59Ro0axaNEi+vbty/PPP8+iRYu4+eab2b59O4MGDWLz5s1h98nLy+Occ87hoYceIioqqsTzvvbaa7z++us8/PDDLF26lMTERG644QZyc3NDx9x77738+uuvzJ8/n/nz5/Prr7/ywAMPnPbnKOoQQ9Q5brfb6NKli/H7778bkydPNp566qmw/fv27TPOOeccY+vWrcXue/XVVxuPPvqoYRiGkZeXZ3Tv3t24+eabS3ycrKysUtvw4IMPGhMmTAjb9uSTTxrdunUL3S44/6233lrs/r/88otx7rnnGq+99topt0UIUTnKutbcc889xsSJE8OO1zTN6N27t/H6668bhmEYuq4b8+bNM/r372+0b9/euOyyy4zly5eHji+4Vq1YscK45pprjPbt2xtvvfWWkZ6ebtx9991Gr169jPbt2xuDBw82li5dGvZYLpfLuP/++41OnToZF110kfHqq68aEyZMMB588MHQMV6v13jmmWeMXr16GR06dDBGjBhhrF27tsznfPXVVxsPP/yw8dhjjxldu3Y1unbtajz11FOGpmmhY/r27Wu8+OKLxqRJk4wuXboYd9xxh2EYhvG///3PGDt2rNGhQwejZ8+exrRp04ycnJzQ/XRdNxYsWGAMHDjQaNu2rdGrVy/jueeeC+0/55xzjE8//TR0+6WXXjIuvvhio23btsbf/vY34/777w/tK3oN9nq9xuOPP25cdNFFRrt27YzRo0cbGzZsCO3//vvvjXPOOcf47rvvjFGjRhkdOnQwhg8fbvzyyy9lvh5C1HTjx483evbsaeTm5hbbV/i9xeuvv25cdtllRseOHY2ePXsaU6ZMCdu/bNkyo1OnTsbXX39tDBkyxGjTpo2xfft249ixY8Ytt9xitG/f3rj44ouNDz74wBgyZIjx4osvltqmgnMV9tFHHxnnnHOOsXPnztDv69dff22MHDnSaNu2rfHVV1+Ve001DMM4fPiwcc899xjdunUzOnToYFx++eXG+vXrS3zcgwcPGrfccotxwQUXGB06dDAuueQSY+XKlaH9Ra9Jv//+u3HdddcZ7du3Ny644ALjwQcfNLKzs0P7C65LixYtMnr27Gl07drVmDRpkpGXlxc6Jicnx/j73/9uzJo1y9B1vcTXZ9WqVcbf/vY3IzU1tcT9nTp1MpYtWxa2Tdd1o0ePHsYrr7wS2uZ2u41OnToZ7777rmEYhrFjxw7jnHPOMTZu3Bg6ZsOGDaHXXYiTIT3jddBnn31G48aNOffcc7niiitYvnz5SX1ium7dOjIyMpgwYUKJ+0+k12Xfvn188803mM3mYucfP358sePbtm3LRRddxMqVK097W4QQp0dZ15rLL7+cr7/+mpycnNDxP/74I0ePHmXIkCEAvPDCCyxdupRp06aRkpLChAkTmD59Ol9//XXY4zz//POMGTOGlJQUBgwYgM/n47zzzuPf//43KSkpXHvttUyfPp3169eH7vPUU0+xYcMG5syZwxtvvMHvv//Oxo0bw847efJkNmzYwKxZs1i5ciXDhw/n1ltv5ffffy/zea9YsQLDMFiyZAmPPvoo77//Pm+88UbYMQsXLuSss85i2bJl3HPPPWzfvp1x48bRr18/PvroI+bMmcPvv//OlClTwp7nK6+8woQJE0hJSWH27Nk0bNiwxDZ8/vnnvP7660yfPp0vvviCV199lQ4dOpTa5oLRRE888QTLly/nnHPO4aabbuLIkSNhx82aNYt7772XDz/8kISEBO677z4Mme0maqnMzEy++eYbxo4di9PpLLa/8HsLRVGYMmUKK1euZNasWWzdupXHHnss7Hiv18srr7zCo48+SkpKCo0bN2bSpEns3buXhQsX8vLLL/PRRx9x4MCBE25rQW9vIBAIbXvuuee46667+PTTT+nYsWO519S8vDyuueYaDhw4wMsvv8yKFSu4/fbbS33MRx99FI/Hw5tvvsnKlSuZMmUKMTExJR6bl5fHuHHjcDgcfPDBB8yZM4fNmzeHXeMANm7cyJ9//smiRYv417/+xZdffsmbb74Z2j9//nzatGnDPffcg8vlYtKkSfTs2ZPhw4fz4YcfMmTIEPr378/o0aN55ZVXKvz67d+/n6NHj9KjR4+w1/SCCy4I9bJv3rwZh8PB+eefHzqmS5cuOByOYj3xQlSUufxDRG2zbNkyrrjiCgC6deuG3W5n9erVXHrppSd0nt27dwNw9tlnn1Q7vvnmGzp37oymaXi9XoCwOVC7du0q8/xnn302H3zwwWlpixDi9CvrWtOjRw9iYmL47LPPGD16NBAMsRdeeCENGjQgLy+PhQsX8vrrr9O1a1cAmjZtytatW3n77be5+OKLQ49z9dVXF7t+Ff4Q78orr+T7779n5cqVXHTRRbhcLj788EOefvrp0BuvmTNnhs393Lt3LykpKXz11Vc0btw49DjfffcdS5Ys4ZFHHin1eTdo0ICpU6eiKApnn302u3fvZuHChdxwww2hY7p168ZNN90Uuv3AAw8waNAgbrzxxtC2Rx55hGHDhpGWlkZUVBSLFi1iypQpjBo1CoDmzZuXWkzp4MGD1K9fnx49emCxWGjcuHGxGiAF8vLyWLJkCY8//njodX300Uf5/vvvefvtt7n77rtDx955551ceOGFANx2222MGTOG1NTUUj8UEKIm27t3L4ZhVOi9xfXXXx/6+YwzzuD+++/ntttu4+mnn0ZVg31fmqbx8MMP065dOyD4Pmft2rW88847dOnSBQh+UDhgwIATaufhw4dZsGABDRs2pEWLFmRkZAAwceJEevbsCVCha+rKlSs5evQoS5YsITExEYBmzZqV+rgHDhzgkksuoXXr1qHzlWblypW43W6eeeYZoqOjAZgxYwbXXnste/bsoXnz5gBER0fz6KOPYjKZOPvss7n00ktZv359qODk8uXLmTdvXui12rlzJy+++CIej4dHH3009IHviBEjGDNmTJnX6sKOHj0KQL169cK2JyUlhT6UPHbsGImJiSiKEtqvKAqJiYkcO3asQo8jRFESxuuYPXv28L///Y/nnnsOCF5Ehg4dytKlS084jJ9qb0jXrl157LHH8Hg8fPDBB+zdu5drrrnmpM4lPTNCVC/lXWvMZjODBw9mxYoVjB49Gp/PxxdffMFDDz0EwI4dO/B6vYwfPz7sjU9BkZ7CCt7YFtA0jXnz5vHJJ59w5MgRfD4ffr+fbt26AcGROH6/P6yn2OFwhBXp2bZtG4ZhhHrpC/h8vlAYLU3Hjh3D2ty5c2dmz55Nbm5u6E1o0TZv27aNPXv28Omnn4a2FVzX9u7di8lkwufzcdFFF5X52AUuvfRS3nzzTfr370/Pnj3p1asX/fv3L3H+5t69e/H7/WG9PSaTiU6dOhWb51+4EGaDBg0ASEtLkzAuaqUTeW+xfv165s2bx86dO8nJyUHXdfx+P0ePHiU5ORkAs9lMmzZtQvfZuXMnqqqGXYuaNGkS+t0qS15eHp07d8YwDNxuN23btuWll14K+x0vfJ2pyDX1119/5dxzzw0F8fJce+21PPLII3zzzTdceOGFDBw4sNi1rfBzPffcc0PXQAheG1VVZceOHaEw3rJlS0wmU+iYBg0asGXLFiBYPC0nJ4dzzjkHCNYVmjNnTujaddtttzF79mwgOF89MzOzQs9DiEiSMF7HfPDBB2iaRt++fUPbCv7YHDp0iEaNGoUulIULVhTIzs4ODUE688wzgeAFtvCbuIqy2+2hi+/UqVO55ppreOWVV0LVQwvOv2PHjtAnxoXt3LmTFi1anJa2CCFOr4pcay6//HKuvPJKUlNT2bJlC36/n4EDB4YdO3fu3FDPdIHC01kgeC0pbMGCBSxcuJApU6Zw7rnn4nA4eP7550lPT69w+w3DQFEUli5dWuzxSiv+cyKKtlnXdUaPHh3Wu1YgOTmZP/7444TO36hRIz777DPWr1/Pd999x9NPP83LL7/M+++/j8PhqPB5Cr9ph/DXvmCfrusn1DYhaormzZujKAo7d+4MXZtKcuDAAW6++Wb+8Y9/8H//93/Ex8fz66+/cs8994RNA7RarWFBs0DR37OKsNvtLF++HFVVSUpKKvH3uvB15kSuqRU1evRoevXqxZo1a/juu+/45z//yc0331xqFfjSFH7+RduiKEqo7YFAIOzDBr/fH/a8C08l2LZtW+g9ZkXUr18fCPZ+F3590tLSQr3l9erVIz09PfT3AYKva3p6erEedSEqSuaM1yGBQIDly5dz7733snz58tDXRx99xLnnnsuyZcsAiI+PJyEhgV9++SXs/rm5uezduzcUfHv06EFCQkJouFBR2dnZJ9S+iRMn8tprr5Gamho6f3x8PAsWLCh27LZt21i/fj1Dhw6tlLYIIU5eRa81HTp0oFmzZqxcuZIVK1bQv3//0Jups88+G6vVysGDB2nevHnYV9Ge8aI2bdpE3759GTZsGG3atKFZs2ahqSwQHEppsVj4+eefQ9vcbjd//vln6HabNm0wDIOjR48We/yCXq7SbNmyJaxH7aeffqJBgwZhPUJFnXfeeaHeoaJfUVFRnHXWWVit1rB57+Wx2WxcfPHFTJkyhaVLl/Lnn3+yadOmYsc1a9YMi8UStk/TNH766SeZ+iPqtPj4eHr27MnixYtxuVzF9he8t/jll1/w+/1MnjyZzp07c+aZZxart1CSs846C13X2bp1a2jbwYMHK3RfRVFo3rw5TZs2rdAHbBW5pp533nls3779hD64bNiwIVdeeSWzZ8/m//7v/3jvvfdKffw//vgjrKNn8+bN6Lpe4etMQkICgUAg9Pp07dqVefPmkZeXR0ZGRqg2x59//smjjz7KuHHjKvw8zjjjDOrXr893330X2ub1etm4cWNoOlDnzp3Jy8sLmx++efPm0CgFIU6GhPE65OuvvyYjI4PRo0dzzjnnhH0NHjyYDz/8MPQG8oYbbuC1117jo48+Yu/evWzdupX77ruPhISE0HB2h8PB448/zrp165gwYQLffvst+/fvZ9u2bbzwwgvcd999J9S+7t2707JlS+bOnRt2/jVr1jB58mR+/fVXDh48SEpKCrfeeitdunTh2muvrZS2CCFO3olca4YOHcoHH3zA119/zeWXXx46R3R0NDfeeCPPPPMMS5cuZc+ePfz222+8++67pb7ZK9CiRQvWr1/Pxo0b2blzJzNmzGD//v2h/U6nkxEjRvDcc8+xfv16duzYwdSpU9F1PdTbceaZZzJ06FAmT57MZ599xr59+/j5559ZsGABX3zxRZmPf+TIEWbOnMlff/3FZ599xoIFC0rs8S7spptuYuvWrUybNo1ff/2VPXv28N///pdp06aFXo9rr72W559/nmXLloWuy++8806J5/vwww/54IMP2L59O/v27ePDDz/EYrGU2FPkcDi46qqreO6551izZg07d+7kkUceIS0tjTFjxpTZbiFqu4Lly0aOHMmnn37KX3/9xc6dO3nnnXdC16zmzZuj6zpvvPEG+/btY+XKlcWKNpbkrLPOolevXkyfPp3Nmzfz22+/MWnSpNMy+qaoilxTL7vsMpKSkrjtttvYuHEj+/btY/Xq1Xz//fclnvPxxx9n7dq17Nu3j99++41vvvmGli1blnjs0KFDiYqK4sEHH2T79u1s2LCBadOm8fe//73CPdiqqtK/f3/efvttAB566CF27txJly5d6NevH+effz4HDhxg/PjxXH311WHriLtcLn777Td+++03dF3n4MGD/Pbbbxw8eBAIfrhx7bXX8tprr/HFF1/wxx9/MGnSJBwOB5dddhkQ/ECh8P+vzZs3M336dPr27ctZZ51Vsf8RQhQhw9TrkKVLl9K9e3cSEhKK7Rs0aBCzZs3i22+/pWfPnowfPx6Hw8H8+fPZv38/MTExdOnShTfffDPsj8SAAQNYsmQJ8+bN4/777yc7O5uGDRvStWtX7r///hNu4w033MDkyZO56aabaNKkCQMHDmTx4sW8+uqrXHfddbjdbpo0acLo0aOZMGFC2HCl090WIcTJOZFrzRVXXMFLL71EUlJSWBVbgLvuuot69erx+uuv88gjjxAdHU2bNm1KXGGhsFtvvZX9+/dz0003ERUVxfDhwxk6dGjY/OcHH3wQt9vNrbfeisPh4Prrr+fYsWNh15Qnn3ySV199lWeffZbU1FTi4uJo37493bt3L/Pxhw4diq7r/OMf/0BRFEaNGlVuGG/dujWLFy/mhRde4Oqrr0bXdZo2bRpWyOnee+8lLi6OV155hdTUVJKSkhg2bFiJ54uNjeW1117j6aefJhAIcPbZZ/PSSy+VWmCp4Bo5efJksrOzOe+883jttdcqNHdViNqsadOmfPjhh/z73//mueeeIzU1lfj4eFq3bs2MGTOA4O/vQw89xGuvvcYLL7xA586deeCBB8KKH5bmqaeeYurUqVx33XUkJCQwceLEE+qZPhHlXVMdDgeLFy/mqaee4pZbbsHv93PmmWeGFdctzDAMHn/8cQ4dOoTT6eSiiy5i0qRJJR5rt9tZsGABTzzxBKNHj8Zms9G/f/9QnZCKuv322xk1ahTt27dnwIABfPzxxxw7dozo6GjMZjPXXHNNiUPGf/nll1AHDsBLL73ESy+9xPDhw3nqqaeA4IeiXq+XGTNmkJWVRceOHXn99dfDRjXNmjWLxx57LNTr3q9fv9CHpkKcDMWQyldCCCHqOJ/PR9++fRk3blxYRfMTdc0119CqVSt5cyaEEJXk+++/58477+SSSy7hqquu4pxzzkFVVXbt2sXbb7/NsWPHQoXchKjupGdcCCFEnfPrr7+yc+dOOnTogMvl4rXXXsPlcjF48OBIN00IIUQZLrzwQpYvX84rr7zC9ddfT3Z2NqqqEh0dzWWXXcbDDz8c6SYKUWESxoUQQtRJCxcuZNeuXZjN5tAwcVmiSwghqr9GjRrx2GOP8eijj5Keno6madSvXz+0prsQNYUMUxdCCCGEEEIIIaqYfHwkhBBCCCGEEEJUMQnjQgghhBBCCCFEFZMwLoQQQgghhBBCVDEJ40IIIYQQQgghRBWTMC6EEEIIIYQQQlQxCeNCCCGEEEIIIUQVkzAuhBBCCCGEEEJUMQnjQgghhBBCCCFEFZMwLoQQQgghhBBCVDEJ40IIIYQQQgghRBWTMC6EEEIIIYQQQlQxCeNCCCGEEEIIIUQVkzAuhBBCCCGEEEJUMQnjQgghhBBCCCFEFZMwLoQQQgghhBBCVDEJ40IIIYQQQgghRBWTMC6EEEIIIYQQQlQxCeNCCCGEEEIIIUQVM0e6AaeLpmlomlbucSaTqULHidNPXvvIqehrb7Vaq6A14mTJda76k9c+cuQ6VzvIda76k9c+ciry2ss1rmapVWE8LS2t3OOSkpIqdJw4/eS1j5yKvvaNGjWqgtaIkyXXuepPXvvIketc7SDXuepPXvvIqchrL9e4mkWGqQshhBBCCCGEEFWs1vSMCyFEJKxdu5aZM2ei6zqjR49mwoQJYfufeOIJfvjhBwA8Hg9paWls3LiR3377jUceeYTc3FxUVeXWW29l8ODBkXgKQgghhBAiAiSMCyHESdI0jRkzZrBw4UKSk5MZNWoU/fr1o2XLlqFjpkyZEvr5rbfe4tdffwUgKiqKp59+mhYtWpCamsrIkSPp2bMnsbGxVf48hBBCCCFE1ZMwLoQQJ2nr1q00b96cpk2bAjBkyBBWr14dFsYLS0lJ4Y477gDgzDPPDG1PTk4mMTGR9PR0CeNCCCGEiBi/38/evXvxeDyRbkqtERUVRbNmzbBYLMX2SRgXQoiTlJqaSsOGDUO3k5OT2bp1a4nHHjhwgP3793PhhRcW27d161b8fj/NmjWrtLYKIYQQQpRn7969mEwmGjRogKIokW5OjWcYBi6Xi71793L22WcX2y9hXAghqkBKSgqXXHIJJpMpbPuRI0e4//77efrpp1HVsmtqmkwmkpKSyn0ss9lcoePE6SevfeTIay+EEKfO4/FIED+NFEXB6XRy5MiREvdXahgvr7DRgQMHmDJlCunp6cTHx/Pss8+GepnGjRvHli1b6NKlC//+978rs5lCCHFSkpOTOXz4cOh2amoqycnJJR77ySefMG3atLBtubm53Hzzzdx999106tSp3MeTJX+qP3ntI0eWNhNCiNNDgvjpVdbrWWlhvCKFjZ5++mmGDRvG8OHDWb9+PbNmzeLZZ58FYPz48bjdbt57773KaqIQQpyS9u3bs3v3bvbt20dycjIpKSnMmjWr2HE7d+4kOzubzp07h7b5fD5uv/12rrjiCi699NKqbLYQQgghRJXKysri//7v/wBIT09HVVXi4+MBmD9/fonzqavCe++9xxVXXEFUVFREHr/SwnhFChvt3LmTyZMnA3DhhRdy++23h/ZddNFFoeWATqtjx1ByczGsVrBaQT75EUKcJLPZzLRp0xg/fjyapjFy5EhatWrF7NmzadeuHf379weCveKDBw8O+2T0008/ZePGjWRmZvKf//wHgKeeeoo2bdpE5LmI08DthiNHULxejKgoKGfagRDi5AT0AKmuVLLd2VhNVlRVxaSYMCkmVEVFVeR3T4jqJi4ujjfeeAOABQsWYLfbGTNmTIRbBe+//z6XXHJJ7QvjFSls1Lp1a7744guuu+46vvzyS1wuFxkZGSQkJFROowwD0tNRMzMxCA4Z0B0OcDoxbDawWCScCyFOSJ8+fejTp0/YtjvvvDPsdkEF9cKuuOIKrrjiikptm6giHg9qejq4XFC/PmpaGqgqekwMRnQ02Gzyt0WI0yigB8hx55Dry0U39GL7VUXFrJqxqlYsqqVYYDcpJhmGK0SEeb1eRo0axZIlSzCbzbhcLq677jqWLFnCXXfdRcuWLdm8eTOapjFlyhTOO+883G43//rXv/jrr78IBAKMGzeOXr16hZ332LFjTJs2DZfLhaZp3HfffXTq1IkffviBBQsW4Pf7adKkCVOmTCElJYVjx45xxx13EBcXx5w5c6r8dYhoAbcHHniAxx57jP/85z907dqV5OTkYsWNKqpChY0MA3N2NvFnnBG6jc93/EtVwemEgjdPEs5PKymuEzny2gtRCTwe1IwMyM0NjrSKiQG7HcPpBF1HyclBycxEsVjQ4+KC2yM0DE+I2kZVVOxme4n7dENHMzQ8moe8QF6Jgd2smDGpJiyqRQK7EBFgs9no3Lkz3333Hb1792bVqlX06dMHszkYTz0eD2+88QY//fQTTzzxBIsXL+aNN96gS5cuTJkyhZycHG666Sa6du2K3X78WvDll1/SvXt3rrvuOjRNw+PxkJmZyRtvvMHs2bOx2+0sXryYJUuWcOONN7JkyRJeeuml0JD5qlZpYbwihY2Sk5NDn0C4XC6++OKLk15jt0KFjQyDpECAjIyMkvfrOmRnowQCwZ5zVUV3OoM95xZL8M2WOGlS2ChypLCREKeR14uSkYGakxP82xATU/wYVYX8NwdGIBDsOT92DCMqCiMhITiM/SQ/fBZClK0iQ9VLDOwGUCh/mxVzsIfdZMVismBWzBLYhTiNhg4dyttvv03v3r1JSUlh0qRJoX0DBw4EoFOnTuTl5ZGTk8OPP/7IunXreOedd4Bg/Z3U1FRatGgRul+bNm144oknCAQC9OrVi3POOYdvv/2W3bt3c8sttwAQCARo165d1T3RMlRaGK9IYaOCKuqqqjJv3jxGjhxZWc2pGFUFmy04ZB0wdB3F7UbJyQn2olsswWHtDkdwzrn0cAghRN3h8x0P4WYzRkkhvCRmM0b+J/34/aiHDoGiBIexx8RAVJSMwhKiip1IYM8L5KH79VBgNxQDAAWlWGC3qJbQuSWwC1G2Dh06MGvWLDZt2oSu65x11lmlHlvwezRz5kyaN29e6nGdOnXi5ZdfZv369cycOZN//vOfxMTEcMEFF/Doo4+e9udwqiotjFeksNGPP/7I888/j6IodO3alenTp4fuP2bMGP766y/y8vLo3bs3M2fOLDYnoNIVCefoOorLhZKdfTycO53BcG6xSDgvgV/349f8uANu3NluXG4XDrMj9AdLCCGqPZ8PJTMTNSsrGMKjo0/+XBZL8O+FYaDk5aHm5IDJhB4bGxzGXvD3RggRcScb2BUUjPz/ygrshYvOSWAXddWll17KI488wg033BC2ffXq1XTp0oUtW7bgdDqJjo6mW7duLF26lHvuuQdFUfjjjz8455xzwu53+PBh6tevz+WXX47P52P79u1cd911PP/88+zfv58zzjgDt9vN0aNHadasGQ6Hg7y8vNo3TB3KL2x06aWXlrqkT8Hwg2pFVSEqCqPgtqah5OaiZGYGezXM5uPh3GoFc0Sn5Fc5wzDw6T58AR95gTw8AQ8BIwAE/6DZdBs5vhwyvZmhP052ix2nxRmasyV/jIQQ1Ybfj5KVFSz6aTIFQ/jpukYpyvG/J7oefIz09OAHwHFxGA5HnfsbIkRNVJHArukaOnqJgR2CPewm1YRZkcAu6p6///3vzJs3jwEDBoRtt1qtXH/99QQCAaZMmQLADTfcwOzZs7n22mvRdZ3GjRuHlsUusGnTJt555x3MZjN2u52HH36YhIQEHnroIaZPn47f7wfgpptuolmzZlx++eXcc8891KtXr+4VcKvxTCYwmYqH86wsMAwMiyXY01FLw7mma/h0H17Ni8vnwqN5jn8KrJqxmCzYlOO9PBaTJazYim7ouANusn3ZAJgUE3azHYfZgc1sw6pa5Q+PEKLqFQ3hTmflDiNX1WD4zn9s9ehRMIzgh7txcbJMmhA1nEk1YaLsGhGarqEbOi6/C92nh95PFQ7sZpM52HmhWIJz2FVzWGA3qVKHQtQM48aNC/28detW+vbtS0yRqV+XXHIJd911V9g2m83GAw88UOa5Bw8ezODBg4tt79KlCwsWLCi2ffTo0YwePfoEWn961a50GGklhfOcnGA4h1A4N+z24FDEGlS8xzCM4JBz3Y/b78YVcBHQAygoKEqwl9thdpxQeFYVFZvJhs1kCz2GT/OFCqkoKMFwbnGEjpO1Q4UQlSYQCIbwjIxgQK7sEF6SgmHsgOLzoRTML4+NlWXShKjFCgK7hdKn8Gm6RkAL4DW86D4dneB7pQJhgV21YFWtmFSTBHZRbT3//PN8//33PPfcc5FuSsRIGK9MJlNwmZuC24EASnY2amZmsOfcZguG86ioahfOdUPHp/nwaT5cARduvzv06axJCS4FYrOc3rmNiqJgNVmxEqxabxgGAT1Aujs9eBsDq8lKtCU61HNuVuWfsBDiFBWE8MzMyIXwklitwVFVJS2T5nDICh9C1DHlBXbDMNANPRjYA150Qw+9dyv4rqIWC+yhHnbVhIoqgV1UmXvuuafE7ZEYLh4pkmSqktkcrKpbcLvwG0BdD4bz6OhgOLdaqzScB/QAPs2HJ+DBFXDh03yhfRY1OLy8qoeMK4oSnDdlOv5Hx6/7yfRmYniChVEsJgsOs0OKwgkhTpymBT8gTU8HRQkG3OoQwosqvEyapoUvkxYfHxxtVY0+zBVCRIaiKMHe75MI7KUOiS8hsJe0brsQ4uRIGI+kouHc7w9W7NWDFznDasWIiQlWc7fZTtucwYJCa37NT14gD7ffHVZozaJacFqcp+WxTreCPwwFNF2TonBCiBOTP4VITc8fdWO315w52SZT+Pzy1FSA4DJp0dHB0C7XPCFEKSoa2DVDw6/5Swzs2Wo22VnZwQrxqjUY2E3W0BrsZsUsBeeEqCAJ49VJ/vJohcN5wZvF0LD2wj3nFXzzeKKF1moSk2rCrkpROCFEBeh6sCc8IyM4GqkmhfCSFF4mze0+vkxaQTCXZdKEECehoBZQaaKt0fhMPjRDw6t5Q7V+MKBgCnt5vetmxSzvx4RAwnj1VqiQD3A8nBv583+iooLh3GYLhfOihdbytDx8mi9YaA0Fi2o54UJrNYkUhRNCFKPrKLm5qGlptSOEF6UowSXRbLbQBw5KRkZwznl8vCyTJoQ47coL7FCo4FyR+esFylt/Xeaui7pA/jrXJIXDuWFAIADHjhLQfPi1AC6LQV6USsBiwrBaManBTySjLdGRbXcESVE4IeqwghCeng6aFhxVVNvnVheaX04gEFomzXA4gsFclkkTQlSR8grO6YaOZmhh668DodGbqqKWOhS+4Ku2di7VZVlZWfzf//0fAOnp6aiqSnx8PADz58/HYim7PtSmTZuwWCy0b9++spt6WkjqqGECegC/HpzDkxfIw6fn93qbwOwzcHoKRggp6HY7utOOYbVhWC0yjxApCidEnaDrKC5XsCc8EAj2hEdFRbpVVc9sxijoEff5UAsvk+Z0Bl8T+bsghIgQVVHLHJ1YMHc9bCh8wb5C0y2tJmuJQ+FNiklGP9ZAcXFxvPHGGwAsWLAAu93OmDFjKnz/zZs3Y7fbJYyLUxc25DzgxhPwoBkaGKCoBWt7Fyq0Zg5O1zGCd0bx+zEfcwd70RUF3eFAd9iDheEknIdUpCicw+LAYXFIUTghqjPDCA/hNlvdDOElKVgmzTCCxeuyssBslmXShBDV1skOhVdQgsFdKbQcr8kmQ+FrsN9//52XXnoJt9tNXFwcDz30EPXq1eODDz5g+fLlmEwmWrRowa233sry5ctRVZXPP/+cu+++m06dOkW6+WWSMF6NaLqGX/fj033k+YK93kXX9rZWtNCaouSH7vw3WIaB4vNhznNR0HceCuc2G4bFLOE8X0lF4fICeWT5soL7pSicENWLYaDk5aEcO4ZSEMKleFnJFAXs9uBfFk0LFrMrWCatIJjX9qH8Qoha42SGwpe0jFtoKLxqxWQyyVD4asQwDP71r3/x1FNPkZCQwKpVq5g3bx5TpkzhrbfeYunSpVitVnJycoiJiWHYsGEn3JseSRLGIyS0bER+r7c74Mav+0OF1syKmSjTaRxCWFY4NwBVDe85l3AeIkXhhKim8quIK8eOofh8wQ8WndVzWcZqyWQKDuGHYIHQI0cA0J1OjNjY4KgCmV8uhKjBKjoU3qf5cAfcJa6hXlBorljveh0YCv/e7+/xzm/vnNZzjmkzhitbX1nh4/1+P3/99Rd33XUXALquk5SUBEDLli159NFH6d27N7169Tqt7awqEsariG7o+LVgr7c74MGjuTHyq6Krilp8yHllKxrOdR3F48XsygUUUBQ0pyNY9MdiCQ5rF0DFi8I5zU6iLFFSFE6I060ghKelBUO41RpcykucvMLLpHm9wfnlqhqcXy7LpAkhaqmKDIXXDR1N18j156L7wtdcB8IKzRXMXy8I6gVhXXrXT55hGJx55pnMmzev2L5nn32Wn376iW+//ZY33niDN998MwItPDWSECpJ0UJrft0PBH/pTZiwqTaU6vRJmqpi2KwYHA/nqtuLkusKzjk3m9HsURgOB7o1uB66CCqtKFyWLytYGE6Kwglx+uTloaaloXi90hNeGUpbJs1iwUhICPaky/VfCFGHqIqKalJLHQpf0Lvu0TxhoyaLDoUvuuZ64cBeXcP6la2vPKFe7MpgtVrJzMzkl19+oV27dgQCAfbu3UuLFi04cuQIXbp0oWPHjqxatQq3243D4cDlckW0zSdCwvhpUFBoLWAEcPuDQ84DRgDFUEKF1uxmR6SbeWJKDOee8HDusAfDucUsb86KkKJwQpxmbncwhHs8wRAuPeGVr6xl0uLiat967UIIcRIKetfNpcQqwzDQDT1UaE4ztFDveoGy1lwvqBBfVymKwuOPP84LL7yAy+UiEAhw5ZVX0qxZM2bMmEFubi6GYTB69GhiYmLo0aMHU6dO5ZtvvpECbrVV4UJrbr8br+YNK7RmVsxYTbVsSJ+qBt8AF9zWNNQ8N0p2TrAnxWQ6Hs6tFjDLP63CKloUzml2YjVbpSicEAXc7uA64W53sCK4hPDIKLpM2uHDskyaEEJUgKIowR7wChaa03waOnpYWC8YCm/Yw0N8bTdu3LjQz6+88kqx/XPnzi22rVmzZjVquLokpnJUeaG1msJkwjCZgkMZ4Xg4z8lFMQx0ixnd4cCw2yWcl0CKwglRDo8nGMJdruB8ZQnh1UfhZdJyc4PLpJlMwWXSnE5ZJk0IIU5QWKG5Eha0KKhPlO3NJo64qm2cqFSSkIooXGjNE/Dg1tzoenCtQlVRsSiWqi20VlMUhPOC25qGmutCycpGURR0ixlVN1C8nuCbOFk6J4wUhRMin9d7PIRbLBATE+kWidIoCkRFhS+TlpYWHEUVHx8cxi4fxAohxClTFEXWRK+l6vxfyYJCaz7NR54/uLY3FCm0ZpIeyRNWNJwHNNSsHCwZ6SiAbrWiOx3oUTYJ5yWQonCizvF6UTIzUbOzg1W9pSe8ZjGZgmuUw/Fl0gwDPTpalkkTQgghSlGpYXzt2rXMnDkTXdcZPXo0EyZMCNt/4MABpkyZQnp6OvHx8Tz77LM0bNgQgP/85z+heQC33norw4cPPy1t8ut+8gJ5tafQWk1hNmHYo9B9+aMK8sO5KTMLMDCsVnSnMxjOLRYJ5yWQonCiVvL5UDIyUHNyMMxmDOkJr/mKLpN2+DDA8WHsNlvdm9olhBBClKDSwrimacyYMYOFCxeSnJzMqFGj6NevHy1btgwd8/TTTzNs2DCGDx/O+vXrmTVrFs8++yyZmZnMmTOHZcuWoSgKI0aMoF+/fsTFndocCcMwOJhziIyALzTkvNYVWqspzCYMc+Ge8wBqZjZmXcNQwLDZ0JzOYEV3q1V6VEpwIkXhogPSyyiqGZ8PJSsLNTMzGMKlJ7z2KVgmDYovk1YQzGUlDiGEEHVYpSWcrVu30rx5c5o2bYrVamXIkCGsXr067JidO3dy4YUXAnDhhReG9q9bt44ePXoQHx9PXFwcPXr04Jtvvjkt7TIMHbvZgc0UhSpzL6oPsxnDHoXmdKI7nMHV09IzsR5MxbpnL5aDh1CzslG8XtD1SLe2WiooChdtiSbaEk2UKQqf5uOo5yh7s/eG1roXIqL8fpRjxzDt3YuSmxsM4XZ7+fcTNVvBMmnR0WAyoaanY9qzB3X/fhSXCzQt0i0UQgghqlylhfHU1NTQkHOA5ORkUlNTw45p3bo1X3zxBQBffvklLpeLjIyMCt1X1HJmM7rDjuZ0oDucoBvBcH7gENbdezEfOoyakyPhvAwFReEcZgeGYZR/ByEqU+EQnpMT7BW122W4cl1kNgfXKo+OBsNAPXQI0549KEeOBJewk+tVtbN27VouueQSBg4cyLx584rtf/fddxk6dChXXHEFV111FTt27ADg22+/ZcSIEQwdOpQRI0awfv36qm66EKKGmThxIj/88EPYtvfee49nn3221ON/++03AO69915ycnKKHbNgwQLeeeedMh937dq17Nq1K3T7tddeY8OGDSfa/BMW0QJuDzzwAI899hj/+c9/6Nq1K8nJyZhOcq6wyWQiKSmpzGMMXce9z0x8tCwJEAkms4n4U5xqAATfqAUCKD4f+AKggG63Y0Q7g0utWa3yBr8Ij+4hKToprCCcEFUiEAgOR8/IAFUNFvmS309RoPD88rw81Jyc4DJpBeuX22QqWaRVZNrh0KFDueqqqwBYvXo1Tz75JAsWLCAhIYG5c+eSnJzMH3/8wbhx407bSEchRO00cOBAVq1aRffu3UPbVq1axe23317ufWfNmnXSj7t27Vp69OjBmWeeCcBNN9100uc6EZUWxpOTkzmcX7QFgj3lycnJxY6ZM2cOAC6Xiy+++ILY2FiSk5P58ccfw+7brVu3Mh9P0zTS0tLKPMbQdbRAgMysrBN9OuI0iI+Lq5zX3jBQ8twoh1ODQV1R0O12dKcdw2rDsFrq/Jt/i9NCWnpauRXXGzVqVEUtErVeQQjPzAyGcKezzv8eijIUXSYtMxMjPT0451yWSYuowtMOgdC0w8JhPLpQzQe32x0qHnreeeeFtrdq1Qqv14vP58Mqa9ELIUrRt29f5s2bh9/vx2KxcOjQIdLS0vjyyy958cUX8Xq99O3bl/Hjxxe778iRI1mwYAHx8fG88cYbfPrppyQkJNCgQQPOPfdcAD7++GM++ugjAoEATZo0Ydq0afz555+sW7eOn376iUWLFjFz5kwWLVpEjx496Nu3Lxs3bmTOnDlomkabNm247777sFqtjBw5kkGDBvHtt98SCAR4/PHHad68+Qk930obpt6+fXt2797Nvn378Pl8pKSk0K9fv7Bj0tPTg2t4A/PmzWPkyJEA9OzZk3Xr1pGVlUVWVhbr1q2jZ8+eldVUUdMpCobFgu5wBCuy2+0ofj/mY+lYDuYPa089ipqTi+LzyxBIISqTpqFkZGDauxc1KwvDbg8GKQnioqIKlknLD3jqkSOYdu9GOXwYJS9PpiZVsYpOHXz77bcZMGAAzz77LFOnTi22//PPP+e8886TIC6EKFNsbCznnXce33//PRDsFe/Xrx8333wzr7/+Om+++SY//fRTaDpMSX7//XdWrVrFokWLeO6550LD2AH69OnDggULeOONN2jRogUrVqygffv29OzZk9tvv5033niDM844I3S81+tl5syZzJgxg7feegtN0/jPf/4T2h8XF8fChQsZPnx4uUPhS1JpHzObzWamTZvG+PHj0TSNkSNH0qpVK2bPnk27du3o378/P/74I88//zyKotC1a1emT58OQHx8PLfddhujRo0C4Pbbbyc+Pr6ymipqG0XBsOZXYYdgz7nPhznPBSjBnnOHA91hDx5nMUtQEOJUaRpKTg5qejoYRjCAyyoI4lQVDGMHFK8X5dCh4DU8NjY451yWSas2xo4dy9ixY1mxYgVz587l6aefDu37888/ee6553j99dfLPU9Fph16Ah48uR6iE2QVhkgwm80kJCREuhl1jm7o6OgkJZT9+3E62d57j6iTCJhl8YwZg/fKK8s8ZsCAAaxatYpevXqxatUqJk+ezOrVq/n4449Do6F3794dNkKnsC1bttC7d2+ioqIAwjp1//rrL+bNm0dubi5ut7vc0dd79+6lUaNGNGvWDIBBgwaxbNkyrsx/DhdffDEA5557LmvWrKnQa1BYpY756tOnD3369Anbduedd4Z+vvTSS7n00ktLvO+oUaNCYVyIU1I0nOs6iseL2ZULBqCqaE5HsKCQxRIc1i6EqJj8JavUjAzQdQnhovLYbMG6ILqOkpODkpmJYrEcX79cVIqKTDssbMiQITzyyCOh24cPH2bixIk8/fTToTezZanItENPwINm1sjIzij/CYjTLiEhgYwMee2rmm7oOGOd5f5+1IYph7169eLFF19k+/bteL1eYmNjeffdd5k/fz6xsbE8/vjjeL3ekzr3zJkzefLJJ2nVqhUpKSls3rz5lNpqyf/AWFVVtJNYGUQmYIm6R1WD65dzPJyrbi9Krit4W1FC4Vy3WmQdXCFKousoubmoaWkSwkXVKlgmDTACgeBojKNHg8ujSU/5aVd42mFycjIpKSnFiiTt3r2bFi1aAPD111+H5kxmZ2czYcIE7r33Xrp06VLVTRdCnCLvlVeW24tdGRwOB+effz5PPPEEAwYMwOVyYbfbiY6OJj09ne+//57OnTuXev9OnToxc+ZMrr32WgKBAN9++y1XXHEFAHl5edSrV49AIMAXX3xB/fr1Q4+Zl5dX7FzNmjXj8OHD7N+/nzPOOIPPPvuszMc+URLGhSgxnHuC4dwwwGxGc9iD4dxilnAu6jZdR3G5giFc0zCiouAkV8EQ4pSZzRgFhd1cLllNoxJUZNrh4sWLWb9+PWazmdjY2NAQ9cWLF7N3715efvllXn75ZQBef/31coehCyHEwIEDmTx5MjNmzKB58+a0atWKMWPG0KBBA9q3b1/mfc8991z69+/PddddR0JCAm3atAntu+mmm7jpppuIj4/nvPPOCwXwAQMG8PTTT/PBBx/w+OOPh4632WxMmTKFqVOnhgq4DRs27LQ9T8WoJQsQ+3y+ClVTz921Ga8ixUMiodKqqVc2TUMJBFACgeCbPJPpeDi3WmpEhV+L00KsHivV1Gu4ilznAJKSkip03AkxjGBPeHo6+P3BnvA6HsJ1Q0c3dAzDCM3li4uPIzMzk7L+tBoY5e4v9TFLKV5WcJ9S72uUvq8y2hM6bxn3LbU95bwt0Sn5MRtYHFiatkEp59+lXOeqt4pc5zwBDy6zC7/LX0WtEoXJMPXIKBimHqeXvUzwqV7jtm3bVuZUFHFyUlNTadu2bbHt1T9FCBFpJhOGyRScqwjBZXfy3Cg5uSiGgW4x51dxjwoWGqoB4VyICjOM4z3hgUDw96CWrv1cUrjWDR3N0AjoATRdC36hoRkauqGjEOyFVVAwMPBYPGTnZZf7WAX3K2XnSSnznOXsP5X7lr2r9J1qaQu65N9FKaOHu6TzegJezBgn+/IJIYQQVU5SgxAnqiCcF9zWNNScXEyZWSiKEgznDkcwnFutdb73sLZbu3YtM2fORNd1Ro8ezYQJE8L2P/HEE/zwww8AeDwe0tLS2LhxIwD/+c9/mDt3LgC33norw4cPr9rGl8UwUPLyUI4dQ6mhIfxEw3XhHtmCcF3ws6IoqKgoioIJU3CUSQlh0Wl24jcHquw5CiGEEKLmkjAuxKkqGs4DhcI5oFut6E7H8Z5zCee1hqZpzJgxg4ULF5KcnMyoUaPo169f2FIbU6ZMCf381ltv8euvvwKQmZnJnDlzWLZsGYqiMGLECPr160dcXNnDzyqdYaC43cEQ7vcHVyKoJpWqTyhc61rYMOiwcK0oKFQsXAshhBBCVBYJ40KcbmYThrlIOM/KwZSZBRgYVmtwWHuULdhzLhWoa6ytW7fSvHlzmjZtCgSX9Fm9enWp616mpKRwxx13ALBu3Tp69OhBfHw8AD169OCbb77hsssuq5K2F2MY4HajpqWh+HxVEsIrGq4DRiB43ImEa5OEayGEEOJkGIZR5lQhcWLKqoUiYVyIylYsnAdQM7Mx6xqGAobNhuZ0Biu6SzivUVJTU2nYsGHodnJyMlu3bi3x2AMHDrB//34uvPDCUu+bmppauQ0uTV5eMIR7vRg220mH8MoK12bFjKqqEq6FEEKIShYVFYXL5cLpdEogPw0Mw8DlchEVFVXifgnjQlS1/KV4tILbgQDm9EwUw8BQQI+yoTscGFG24LB2Cee1QkpKCpdccgmmU5imYDKZKrQkkNlsrtjSQW43HDsGeXkQHx9cFqqQosFa04NFywoCtaYH51r7NT8BPRAsvFXwd1vJ/2QdBVVRsSgWLIoFFRVVCX6VVzSsJjKZTcRHeqpBHeXLSScpKQnVJG9thBDiZDVr1oy9e/dy5MiRSDel1oiKiqJZs2Yl7pO/WEJEmtmMXqgCu+L354dzHQPQ7Xb0aEdw2LCsoVutJCcnc/jw4dDt1NTUUpcD+eSTT5g2bVrYfX/88cew+3br1q3Mx9M07ZSWNivoudbdeZAWDOGaxYRmMRHIDYbrgB5AM4IhuzAFBR09VMyscM91QcCWf5s1eAnHWsBqBH8/ygvjsrSZEEKUzmKxcPbZZ0e6GXWGhHEhqhnDYgn2iEOwmFYggPlYOvkLBRcK5zYMq8yLjaT27duze/du9u3bR3JyMikpKcyaNavYcTt37iQ7O5vOnTuHtvXs2ZPnn3+erPzgtm7dOu65555TbpNhGGS6MznmPoama/h1f6gnW/F6MWdkYcpzg8WKZjOjaAqKXnxYuFWVD36EEEIIISqThHEhqjNFKT2cGwYoSjCcOwt6ziWcVyWz2cy0adMYP348mqYxcuRIWrVqxezZs2nXrh39+/cHgr3igwcPDpt7FR8fz2233caoUaMAuP3220PF3E6FZmikudLI9eUGh4IrCpaAjiPThSkvD8NsxYiPPuXHEUIIIYQQp0YxyirvVoP4fL5yh28auk7urs14FWuZx4nKIcM3K4FhoPj9KAE/BZN1dYcD3WEPFuKymEFRsDgtxOqxweWbyiDDN6u3ilznAnqALDULv8uP4vWhZmVhyskNfqhTw9YJr4nkOhc5VsNHdIuOMky9hqvIdc4T8OAyu/C7/FXUKlFYQkICGRkZkW5GnaMbOs5YJ3F62XVJ5BpXs0jPuBA1maIcn0sOwXDu82HOc4EBqCq6w4HaIA6iYiLaVFF1FJ8f09FjwRBuNqNHS0+4EKIWCQQwZaah5/qCRU7zV1swFAVUBZT8wqeKEhotZijht0HJvw/Fjg39LCPNhBCVTMK4ELVJ0XCu6ygeL+aDqdAsCUwyKqTW0zQs+w9ieDT0Sl4nXAghIkEJaJgystAC+WHZCNZUAVAMg2CNFSN/wFihYxQFxQBDKRgUWmQfHF9y0Si0X1VAVcMCvaGqFAT60D6QDwfEqSs8aDnsZz38tqgVJIwLUZupKobNCoYv0i0RVcUwMAwDo5T1LIUQdVNOTg7ffPMNqampQHBFh549exIbGxvhlp0kVSlx6s1pjyoF4ccwCv0M6AaKoYf2hfJ9wQcB5X04QMH+0/nhAMHgX9kfDuh68KtoMCzjtmKUcVzR/2ulhdHyzlPsfoVu60XOo+vhxxa+b6F9StGmFr1foccIPydF9hVpm1F624q9HgUvu2FgToyHJvGI2kPCuBBCCCFELbZ8+XLmzJlDjx49Qssvfv/99zz//PNMnDiRYcOGRbaB1Vnh3ukiKhL8q/bDAQPQT/nDATDyQ3jJHw6YsrKx5tfGUArf3zCCgb9iT6TIYx6/n1H4FPmPXfIpjCLNL3pc+O2wthXeVez8Suk3ldLPaaCG36fwS2Mqes5ybpfA0AKgBco9TtQsEsaFEEIIIWqxuXPn8uGHHxbrBc/KyuIf//iHhPGapDp8OOBwovslFApxOqjlHyKEEEIIIWoypYTwpqoqtWRRHSGEqJEqtWd87dq1zJw5E13XGT16NBMmTAjbf/DgQR588EFycnLQNI377ruPPn364PP5mD59Or/88guKovDQQw/RvXv3ymyqEEIIIUStdMsttzB8+HB69OgRWvbo4MGDfPfdd9x2220Rbp0QQtRdlRbGNU1jxowZLFy4kOTkZEaNGkW/fv1o2bJl6Ji5c+cyaNAgxowZw44dO5gwYQJfffUVH3zwAQArVqwgLS2Nm266iaVLl6Kq0pEvhBBCCHEihg8fTr9+/Vi3bl2ogFv37t259957iYsre81iIYQQlafSwvjWrVtp3rw5TZs2BWDIkCGsXr06LIwrikJubi4QrPLZoEEDAHbs2BHqCU9KSiImJoZffvmFDh06VFZzhRB13KZNmzhw4ACapoW2yTxKIURtERcXR/fu3cOqqUsQF0KIyKq0MJ6amkrDhg1Dt5OTk9m6dWvYMRMnTmTcuHEsXrwYt9vNwoULAWjdujVfffUVl112GYcOHWLbtm0cOnRIwrgQolLcf//97Nu3j9atW2MymYDgh4USxoUQtcFvv/3G9OnTycnJoWHDhhiGweHDh4mNjWX69Om0bds20k0UQog6KaLV1FNSUhg+fDg33ngjmzdv5oEHHmDlypWMHDmSnTt3MnLkSBo3bkznzp1Db5BLYzKZSEpKKvMYQ9dx7zMTHy2fBEeCyWwiXj6FjwhfbjpJiUlYohyRbkq19Msvv/DJJ5+UWOBICCFqukmTJjFjxgw6duwYtv2nn35i8uTJfPzxxxFqmRBC1G2VFsaTk5M5fPhw6HZqampobcsCS5cuZf78+QB07twZr9dLRkYGSUlJTJkyJXTcP//5T1q0aFHm42maRlpaWpnHGLqOFgiQmb82oqha8XFx8tpHiM3QSEtPw2Jzl3lcQWGfuqZVq1YcPXo0NFVGCCFqE7fbXSyIA3Tq1Am3u+y/C0IIISpPpYXx9u3bs3v3bvbt20dycjIpKSnMmjUr7JhGjRqxfv16RowYwc6dO/F6vSQmJuJ2uzEMA4fDwbfffovJZAqbay6EEKdTRkYGQ4YMoUOHDlgsltD2V199NYKtEkKI06N3795MmDCBYcOGhaYQHj58mOXLl9OrV68It04IIequSgvjZrOZadOmMX78eDRNY+TIkbRq1YrZs2fTrl07+vfvz6RJk5g6dSqLFi1CURSeeuopFEUhLS2NcePGoaoqycnJPPPMM5XVTCGE4I477oh0E4QQotJMnTqVNWvWsHr1ao4cOQJAgwYNGDt2LH369Ilw64QQou5SDMMwIt2I08Hn81VomHrurs14FWsVtUoUJsPUI8dm+Ig6ow0WW9lzxuvqMHWAY8eO8fPPPwPQoUOHcmtQREJFrnMBn4e8fdvwyXUuIuQ6FzlWw0d0i46oprL7Geryda4mqMh1zpubhS/1T7yKrYpaJQqT61xkGFoAh82Ms1n7Mo+Ta1zNIgt3CyHqvE8++YTRo0fz2Wef8emnn4Z+FkKI2u7hhx+OdBOEEKLOimg1dSGEqA5effVVli5dGuoNT09P5/rrr+fSSy+NcMuEEOLUZWZmlrjdMAzWrFlTtY0RQggRImFcCFHnGYYRNiw9Pj6eWjKDRwghuOiii2jcuHHYdU1RFAzDID09PYItE0KIuk3CuBCizuvZsyfjxo1jyJAhQHDYeu/evSPcKiGEOD2aNm3KokWLaNy4cbF9UsBNCCEiR8K4EKLOe/DBB/n888/ZtGkTAFdeeSUDBw6McKuEEOL0uO6668jOzi4xjI8fPz4CLRJCCAESxoUQAoBLLrmESy65JNLNEEKI027s2LGl7rvmmmuqsCVCCCEKkzAuhKizrrrqKt599106d+6Moiih7YZhoChKqKdcCBEhAQ1Tngs1Nw+Ty4XqysOU6wr+XPDdFdznuaAjtOgY6RZXaz6fj7Vr17J3714SExPp27cvcXFxkW6WEELUWRLGhRB11rvvvgvA5s2bI9wSIWofxecLBeWCMG3KdaHmfzfl5R0P1LkuTPlBW83LO36c21Pu4+gWC7k2Bz94oul4bRU8sRrqyy+/5PXXX2fQoEG0bNmS9PR07rzzTu6//37atm0b6eaJGiCga3h0DzFGdKSbIkStIWFcCFHn7d27l4YNG2K1Wvnhhx/Yvn07w4YNIzY2NtJNE6LqGQaK11uoBzovrCfa5MoLBerg9/Bea9WVfz+fv9yH0qNsaE4nWrQT3eFAi3bib1AfLdqJ5nSgRzvRnE50pyN/mzO0reA+hs0KwNmGr7JfmRpr06ZNLFmyhEWLFvHrr78SCARo0qQJV199NS+88AKXXnopLVq0oEuXLpFuqjgFhmHg1r14NA/uEr48urfE7cGv/H16+G1Pof1+I/g7bVUtNIpKpqm9EWfYG9LU3pgzHI04I/+23RQV4VdCiJpDwrgQos674447WLZsGXv27GHatGn069ePe++9l9deey3STRPixOg6qtudH4oLDekuHJSLDO8u1mvtykPRtHIfSnM6woNyfBy+Jo3Roh3ozvAwrUU7g9uinWiOgu0OMMvbkKowf/58pk+fjs1mIyUlhZ9//pkLLriADRs20LlzZ/72t78xY8YMCeOVzDAMAkYAt+Yh7wTCsqdYUC4SoAvd/0RFqTbspqj8r+M/N7AlBn9Wo4gqtD3KZMOteNmRuZt97kP8lLmNXC0v7Jz1rYnBYO5olB/Y8787GpNoiQubFiZEXSd/BYUQdZ6qqpjNZr788kuuvvpqrrnmGoYNGxbpZom6psj86FCgLtwrXSgwlzh/Os+NUmgt6ZIYJrVQIHaGeqM9Z7XI7512hPVA6/kBunCg1h12UNUqemHKN2dLABWY2iLSLameDh06RLNmzQDYvn07b731FlarFa/Xy0033USjRo3Yv39/hFtZPWiGdjz8Fv46waBc8jk8aIZ+Qu2xKJZQSI4qFJpjLTEk2+oXC9GFv8KDdqHtof1WVOXEf4/j4+LIzMoCgh8wZPlz2Oc+yD73Ifa7D7E/7xD73If4Mf0nVnhXhd3XYbKHetOb2BvS1NEo2LNub0ijqGQsqkQTUbfIv3ghRJ1nNptZuXIly5cvZ+7cuQAEAoEIt0rUNIrXi3nPXuyHU0vuiQ6bJx2+X83Lq/D86KJDtr3xjQsFa8fxHuiCXuuCQJ2/zYiyQS3rmTrgArXszyDqNLPZTG5uLtHR0ei6zl9//UXr1q3ZtWsXgUAAn89HVFTpQ4vXrl3LzJkz0XWd0aNHM2HChLD97777Lu+88w6qquJwOHjsscdo2bIlAP/+979ZunQpqqoydepUevXqdcrPx6/7Sfdlk6XrJzj0uuyg7NG8ePUTm+6gooZ6jMNDr414S2yhAF0kNKulbC8cutUozKrplF+vyqQoCvHWWOKtsbSPa11sv1fzccBzmP3uQ+zLD+n73YfYlbePb9J+xKcfn85iUlQaRjUI9aaHetTtjWjqaES02VmVT02IKiFhXAhR5z355JMsWbKEW265haZNm7Jv3z4uv/zySDdL1ACKz0f0DxuJX7WG2G/Xo3pKHyZ6OudHC3EiBg0axNtvv83NN9/ME088waxZs8jMzCQ+Pp6ZM2fy4Ycf0q9fvxLvq2kaM2bMYOHChSQnJzNq1Cj69esXCtsAQ4cO5aqrrgJg9erVPPnkkyxYsIAdO3aQkpJCSkoKqamp3HDDDXz++eeYTKcWMC/95Ar+yt5V4eOjVFvxsKxGkWRNKCFEB8NxlFq8R9lROHTn77eqFhl2XQabycpZzmac5WxWbJ9u6Bz1pucH9IPsdx9mX16wh33VkXVk+rPDjk+wxAV70+2NaOoI9qafYW9MU3sj6tsST6qXX4hIkzAuhKjzWrZsydSpU0O3mzZtWqznR4iQgEb0pp+IW/U1cWu/xZTrIhAXS8alA+CCLuSYVJkfLaqVq6++mgkTJhAfH8+VV17Jiy++GNq3bNkyUlJSWLBgQYn33bp1K82bN6dp06YADBkyhNWrV4eF8ejo49W13W53KJyuXr2aIUOGYLVaadq0Kc2bN2fr1q107tz5lJ7Pg53uZe/hLVhM0UV6lINB2aGGb5OQVj2pikpyVD2So+rRNaF9sf05AVdoyPv+/K997oNszf6dz1PXonN8yL9NtdLE3rBYb3pTeyMaRzXEZpIPMkX1VOo7g/T0dNLT08MutgA7duwgMTGRxMTESm+cEEJUpjvvvJPZs2czdOjQEvevWLGiilskqi1dx/HzNuJXrSHuv2sxZ2ahOR1k9+5BZv8+5HbtDGYz8XFx5OTPpRSiurBarcybN4958+YxevRoGjVqhMlk4tChQ3Tv3p3XXnsNq7XksJKamkrDhg1Dt5OTk9m6dWux495++20WLlyI3+/njTfeCN23Y8eOYfdNTU095efz9zP647M0w6vYTvlcovqKMTtpE9uSNrEti+3z6wEOeVKDvenug+zLO8SB/J83ZGzBrR2f9qOg0MCWFJqbfkaheepN7Y2Js8TI6AYRMaWG8ccee4wxY8YU256ZmcncuXOZNWtWpTZMCCEq20MPPQTAq6++GuGWiGrJMLBv/zPYA/7VGqxHjqHbbGT36E5W/4vJufACGTZeTZwVqyB9n2WzWq1MnDiRiRMnkp6eDnBaO1bGjh3L2LFjWbFiBXPnzuXpp58+qfOYTCaSkpLKPMZjM3HkqIn42LiTegxxakxmE/FxkX/t65NEB84rtt0wDNK8GexxHWCPaz97XQfZkxv8+buMTRw5dCzs+FhLNM2cjWnmPIPmziY0j25CM2cTmjub0NiRjEmpHvP2dT2A4fWW+/shapZSw/iePXu44IILim3v2rUrjzzySGW2SQghqkSDBg0A0HWdBg0aYLMFe1k8Hg/Hjh0r666iFrP9tZv4VV8Tt/prbAcOoZvN5HbvyuFbxpHT86JgJXFRrdzUzoTVKH85NhFcc/zAgQNohZavK2v1iOTkZA4fPhy6nZqaSnJycqnHDxkyJPQ+8UTvC8E56mlpaWUe483NQte1UEVvUbUKV1OvrsyYONvcjLPjmkGRzw3cmof97sOFKr8H56tvy/iDLw6uJWAcL+BqVkw0jkou1ptesK66owrXVDe0AA6budzfj0aNGlVRi8TpUGoYd7lcpd7J7/eXuk8IIWqaO++8kyVLloRuq6rKnXfeybJlyyLYKlGVrAcOErfqa+JXryHqr90Yqkru+R05es0/yerdAz02JtJNFOKU3X///ezbt4/WrVuHiqgpilJmGG/fvj27d+9m3759JCcnk5KSUmx05O7du2nRogUAX3/9Nc2bNwegX79+3Hvvvdxwww2kpqaye/duOnToUCnPTYiKspuiaBXdglbRLYrt0wyNI960UCG50Fz1vEP8nLWdnEBu2PFJ1oTw6u+O41Xgk6wJMvxdlKvUMN68eXPWrFlDnz59wravWbMmVMRDCCFqA03TwuZLWq1W+dCxDjAfOUr8V2uJW/01jt/+AMDVvi0H7r6d7L69CCQmRLiFoqJmbQquM/5Yi0i3pHr75Zdf+OSTT04oIJjNZqZNm8b48ePRNI2RI0fSqlUrZs+eTbt27ejfvz+LFy9m/fr1mM1mYmNjQ0PUW7VqxaBBgxg8eDAmk4lp06adciV1ISqTSTHRKKoBjaIa0I1OxfZn+3PY5z7Evrz86u/5leD/l/kzKYe/wuD4Got2U1R+SG+YH9jze9YdjWkc1QCLaqnCZyaqq1LD+JQpU7j55pv59NNPadu2LRC8iP/0008Vnl9Z3rqUBw8e5MEHHyQnJwdN07jvvvvo06cPfr+fqVOn8uuvvxIIBBg2bBg333zzKTzNIPXgQZzfbUBJakAgMR4tIR7DIr8IQtR1iYmJrF69mv79+wOwatUqEhIkiNVGpoxM4r7+hrjVa3Bu+QXFMHCf05JDt40nq18f/A0bRLqJ4iQc88g64xXRqlUrjh49GpqiU1F9+vQp1jlz5513hn4uvBpFUbfeeiu33nrriTVUiGoq1hJDW0sMbWPPKbbPp/s44E7NHwIfLCq3332IvXkHWZ+2CY9+fOlLFZWGUfWL9aYX9LDHWqKLnV/UTqWG8RYtWrBixQpWrFjBn3/+CcAFF1zAjBkzQvMqy1KRdSnnzp3LoEGDGDNmDDt27GDChAl89dVXfPbZZ/h8PlasWIHb7WbIkCEMGTKEM84445Se7PZbJ9Pnf6vDtgViYwgkJoR9+YvcDiQmEIiPB7N8mitEbfToo49y3333MWPGDBRFoWHDhiddfEhUP2pOLrHffEf8qq+J/t9mFE3H06IZR8ZdQ2a/PviandrfFiFqioyMDIYMGUKHDh2wFOqMkCKWQpw6q2rlTGdTznQWH0FsGAbHfOn5veqFl2o7xH+Prifdlxl2fJwlJnz4u70xTWz1ubBBO5xV9HxE1Shz0VOr1Uq3bt1C1TZbtmxZoSAOFVuXUlEUcnODcy9ycnJCn9QqioLb7SYQCODxeLBYLGFrWJ6sV666jxUXDmJi01zMaRlYMjIwp2Vgzv9u//0PzGkZmNzuYvc1FAUtLrb0sF74Ky4WZBiWEDVGs2bNeP/990O1MpxO+VNX0yluD7HffU/cqjXEfL8B1e/H16ghR8eMJqv/xXjOPhNkLp+oY+64445IN0GIOklRFOrbkqhvS+L8+HbF9rsCefkBPXyptm3Zf7DqyDoC+QUqx7UYyWMtulR180UlKjWM5+bm8tBDD7Ft2zbatGmDYRj89ttvtG3blieeeKLccFyRdSknTpzIuHHjWLx4MW63m4ULFwJwySWXsHr1anr27InH42Hy5MnEx8efwtMM8lmj+KPZueT0KHspGsXtwZxePKwX/u78+VfM6RmoXm+x+xuqSiA+7ng4T4gnkJQY+u4vdFuLiwVVFmQRIpKOHTvG888/z5EjR5g/fz47duxg8+bNjB49utz7ljcdB+CTTz5hzpw5KIpC69atQ8WPnnnmGdasWYOu6/To0YOHHnpIir2cAsXnI/rH/xH/5dfEfrse1ePFn5RI+vDLyOx/Me7zzpUALuq0bt26cezYMX7++WcAOnToIMskCVENOM0Ozo05m3Njzi62L6BrHPYeZX/ufjolFR8eL2q2UsP4448/TsuWLfnXv/6Fmh8WDcPg5ZdfZsaMGTzzzDOn/OApKSkMHz6cG2+8kc2bN/PAAw+wcuVKtm7diqqqfPPNN2RnZzNmzBj+9re/lVk4riLrUl5wZj1yUvPKXxsxLg4aHl96Qwd8+V9hDAMlLw9TWjrqsTRMaemYjqWjpqVjyr9tTUvDvv8ApmPpKL5iZ8AwmdATE9DqJaIlJqLXS0JLSkSrl4Se/11LSkSvl4geG1uj30hWl3Up6yJfbjpJiUlYohyRbkq1NGnSJEaMGBEaqtmiRQvuvvvucsN4Rabj7N69m3nz5vHuu+8SFxcXWpJk06ZNbNq0iY8//hiAMWPG8OOPP9K9e/dKepa1VEAjevNPxH35NXFrv8WU6yIQF0vGJf3J6n8xro7tZKRSHdA6QcEkc8bL9cknn/Dss8/SrVs3DMPgscce44EHHuDSSy+NdNOEEKUwqybOsDekibUeDmuZg5pFDVTq/9FNmzbx1FNPhW1TFIWJEyfy97//vdwTV2RtyaVLlzJ//nwAOnfujNfrJSMjg5UrV9KrVy8sFgtJSUmcf/75/Pzzz2WG8YqsS3l95wRyd+0+/WsjxsUGv84+s/RjDAPVlYc5PR1zeiaWtHTMGZmYC76np2NOS8fy5w7s6ZmogUCxU+hmM4HEeAIJCQSSEoLfi853z9+uRzurXXCvCetS1lY2QyMtPQ2LrfgUjMLq6tqUGRkZDB48mHnz5gHB6sFqBUasVGQ6zvvvv8/YsWOJy/8gquBDQ0VR8Pl8+P1+DMPA7/dTr1690/3Uaiddx/Hzr8G1wP+7FnNmFprDQXbvv5E54GJyu3YGs7xhqUuuayPrjFfEq6++ytKlS0PXofT0dK6//noJ40IIESEn9W7FMMr/+Lki61I2atSI9evXM2LECHbu3InX6yUxMZFGjRrxww8/MGzYMPLy8tiyZQvXXXfdyTS1+lAU9GgnvmgnvmblLA1nGJhycjCnZ4bCuzk9I/RlSc/Aciwd+x87MWdkomjF34DoVkvJYb3o/PakBHS7vdoF9zrLMFB8PhSvD7Xwd58P1Zv/vej2ko73ht/Hd15L3JOmRfrZVVsOh4OMjIzQEPGffvqJmJjy15WuyHSc3bt3A/DPf/4TXdeZOHEivXv3pnPnznTv3p2ePXtiGAZXX301Z59dfHiayGcYRG3fQfyq/xL31RqsR46hW61k9+hO1oC+5Fx4AYat7ClIQtR1hmGEjSKMj4+v0Hs6IYQQlaPUMN65c2fmzJnD7bffHjaH8eWXX6ZTp07ln7gC61JOmjSJqVOnsmjRIhRF4amnnkJRFMaOHcvkyZMZMmQIhmEwYsQIWrdufcpPdsonuwi44MELTvlUlUtR0GJj0WJj8bZoVvaxuo4pO6dYWA+7nXokWJwuIxNF14ufwmYrEtbjSyxM509MxLBHVdKTrkYMAyUQKBKEvSg+f/42L4rXnx96vag+f6FjfMHbXm/+ff2h7YV/Lu0Y1Xdqa1vrZjOG1YphtaDbbBhWK7rVgtZYlmsqy6RJk7j11lvZu3cv//znP8nIyGD27Nmn5dyaprFnzx7eeustDh8+zNVXX82KFSvIyMhg586drFmzBoAbb7yRjRs30rVr11LPVZHpOAGfB99BE46Y2jElxLzjLxyffonjsy+x7N2PYTbj6dGdtHvuwH1xTwynExWoLs9WpuNExtQ12egBhde6JKGaZFREaXr27Mm4ceMYMmQIEBy23rt37wi3Sggh6q5S/2I9/PDDTJkyhYEDB9KmTRsAfvvtN8477zwef/zxCp28vHUpW7ZsyZIlS4rdz+l08uKLL1boMU5ElieAVnzads2mqmjxcWjxcXjPalH2sZqGKTsnf4h8fjG6gtCeP2TeevAQzp+3YcrKRinh03LNHhUe0gsNmS8YIh9ICu4zKlh5v1QBrVDgLSvYltKDXMr3MnuZC445hZ4CQ1XRbdb8UGwN/axbrRg2K7rdjhYXV3x7kePD7msreowtGLitVgybLX+7pdS5sTbDRx34GOWkaJrGhg0bWLx4Mbt27cIwDM4888ywZX9KU5HpOMnJyXTs2BGLxULTpk1p0aIFu3fv5scff6Rjx46hyu29evVi8+bNZYbxikzHCfg8BDSNvBo8JcR64CBxq9cQt3oN9p27MFQVV+cOpI4ZTXbvv6HFxgYPDASgmj1PmY4TGWl5AVTDIC0trdwwXlen4wA8+OCDfP7552zatAmAK6+8koEDB0a4VUIIUXeV+hcrOjqaF198kb1797Jjxw4A7r//fpo1K6enVlRfJhNaQjxaQnz5xwY0zJmZ4fPa09KxFLpt27MP508/Y87KLvEUmtMRFtbNsTHEuFzHe5kL9TgHQ3B+L3NB77NWvBf/RBQNt0W/azHOUoKtJWz78Z+DvcyFw29oe6GwjMkkw/5rEJPJxMqVK7n++utp1arVCd23ItNxBgwYQEpKCiNHjiQ9PZ3du3fTtGlT9u/fz/vvv08gEMAwDDZs2FDzp+OcAvPRY8R9tZb4VV/j+G07AK7253Hw7tvIurgXgaTECLdQiNrhkksu4ZJLLol0M4QQQlCBOePNmjULC+C7du1iwYIFFe4dFzWU2USgXhKBeknQqpx5rIFAfhG64kPkC75su3Zj9vkxWfKHUeeHXi02tvwwbKtAGC7Su2xYLRKIRYWdf/75zJgxg8GDB2O320Pb27ZtW+b9KjIdp1evXnz77bcMHjwYk8nEAw88QEJCApdccgnff/89Q4cORVEUevXqRb9+/Sr7qVYrpoxM4tasI27VGpxbfkYxDNzntOTQbePJ6tcbf8Pk8k8ihCjXVVddxbvvvkvnzp3Dph4ahoGiKKGeciGEEFVLMUqp3PH777/zzDPPcOTIEfr378/YsWN57LHH2LJlCzfeeCPXX399FTe1bD6fr9zhm7ct3Y7mzmVmOeuMi8ohwzcjx2b4iDqjDRZb2Uub1dXhm9dcc02xbYqi8Oabb0agNaWryHUu4POQt28bPqV6XufUXBex33xH/Jf/Jfp/m1E0HU/zpmQNuJjM/n3KL3BZzcl1LjImfxdANXTmjukow9RruIpc57y5WfhS/8SrnOJ0OHFS5DoXGYYWwGEz42zWvszj5BpXs5Q5Z/yqq66iU6dOrF27lmHDhjFs2DCee+45bKc6FzhCup4RgzcjN9LNqHK6oRMwAvj1AD7dj98I4Nf9+PVAoZ8Lbc8/tuBnX+jY4PdAoZ99pd4v/z6Fjo22OWlkqU9TR2Oa2hvTzNGYpvZGxFrKr1otRGV66623It2EWk3xeIj99gfiVn1NzPcbUP1+fI2SOXrVaLL698HT8iwZySJOScd6ss54Rezdu5eGDRtitVr54Ycf2L59O8OGDSO2oA6DEEKIKlVqGPf5fIwYMQKAs846i7feeosHHnigyhpWGW7o1pDcXYfwnqbzGYZBwNDwGwEC+YHVZ/iLB91CgTZQOLSGBdri4TUQul/JAblwKC4csH2hc/kJGAEClbD2qoKCVbVgUcxYVAsW1Yy54GfFHNynmrEoFhwmOxaLGQ8+1qdv4qNDX4adK84SQ1N7I5raGxcL6knWhLAhdUJUhoyMDF5++WX+97//oSgK559/PrfffjsJCQmRblqNpfh8RP+4ifhV/yXm2+8xuT34kxJJHzaEzP4X427bWgK4OG3+eY6sM14Rd9xxB8uWLWPPnj1MmzaNfv36ce+99/Laa69FumlCCFEnlRrGvV4vv/76a2j9SavVGna7vLmU1dH3h77nkz/fwWPo5fbiFu7xDZTRU1wZLEp+kM0Ps8Hv+bdVa+hnq8mCU3GE9ltVa3goDt3PUig4Hz+nOf9na5Fjjz+WBatiCR5X5P4mRT3hkFwwrMmtedjvPsy+vIPscx9kb95B9rsPsTX7dz5PXYvO8cJtdlNUWFBvZm/MGY5GNLM3JjmqHial5OrhQpyIe+65h65du4ZWcVixYgV33303ixYtimzDapqARvTmn4hbtYa4Nd9iys0lEBtD5sB+ZA3og6tj+1Ir/gshKp+qqpjNZr788kuuvvpqrrnmGoYNGxbpZgkhRJ1VahivX78+Tz75ZOh2vXr1Qrer41zKipj81fvsdKfgMJccPoOBNRg+YyzOsCAcDKzhQdVcpAc47Ltqzg+yZTxWSQFZMdf6nmC7KYpW0S1oFd2i2D6/7ueg50goqO/LO8Re90F25e1j7bEfwz4AsSgWmtiTC/WoN6KZozFn2Btxhr0hFrX8pamEADh69Ci333576PZtt93Gp59+GsEW1SC6juPnX4lf/TWx//0GS0YmmsNBdq+LyBzQl9wLOoNZ1n0WlWv69wFUYHaLSLekejObzaxcuZLly5czd+5cAAKBQIRbJYQQdVep75Bq4xzK8+y3ci7XSAG3asyiWmjuaEJzR5Ni+zRD44g3jX15B9nrPsj+/KC+P+8Q/8v8mTzNHTpWRaVhVH2aOvJ71QsNfT/D0RiHSVbdFsf16NGDlJQUBg0aBMBnn31Gz549I9yqaswwiNq+g/jVXxO3eg3WI0fRrVaye3Qna8DF5Fx4AUYNrS0iaiafDqrMGS/Xk08+yZIlS7jlllto2rQp+/bt4/LLL490s4QQos4qtZp6TSPV1Ku/yqy+aRgG6f4s9uUdYJ/7EHsL9azvcx8k0x++Fno9a2IoqBce+t7U0Yg4S+0rZCPV1MvWuXNn3G43pvwh1JqmhZY4q07L/kS6mrpt1x7iVn9N/Ko12PYfwDCZyOnelawBF5Pd80J0R9n/vuoCqTIcGVJNvfaQaurVn1znIkOqqddOMnZQ1AqKopBkjSfJGk+n+OL1DLL9uex3Hwqbo7437yDfp2/mY294QblYc3SokFzhoe/NHI2pZ02s9dMI6qLNmzdHugnVluXAIeK/WkPcqq+x79yFoaq4Onfg6NjRZPfpgSZVmIWo9u68805mz57N0KFDS9y/YsWKKm6REEIIkDAu6ohYSzTnWVpxXmyrYvvcmocD+QXl9roPss99iH15B/kleztfHlmLZhwvKBel2ooVkmtqb0RTR2MaRtWXgnKiVjAfPUbcf9cS/+XXOH7bDoCr/XkcvOs2svr2IpCUGOEWCiFOxEMPPQTAq6++GuGWCCGEKKzUMP7NN9/gcrm49NJLw7Z/9tlnxMTE0KNHj0pv3OnWo0Uc3vS6t864KJvdFEXL6Ba0LLGgXIBDntSw3vR97kPsytvHN2k/4tOPF5QzK2aa2BsW601vam9EE3tDrKpMjxDVlykzi7iv1xG36mucW35GMQzc57Tk0K3jyOrXG3+jhpFuohCluiBZ1hkvS4MGDQDQdZ0GDRpgy6/p4PF4OHbsWCSbJoQQdVqpYfzll1/mlVdeKba9W7du3HrrrTUyjI85vwG5uw6ctnXGRe1nUc00czShWQkF5XRD54j3WKji+768473qmzO34dLyQscqKMGCcvnz0gsXlGtqb4zDbK/KpyUEAGqui9hvviN+1ddEb9yEoul4mp3BkRuuJnNAH3zNmka6iUJUyIizZZ3xirjzzjtZsmRJ6Laqqtx5550sW7Ysgq0SQoi6q9Qw7vP5SEwsPhQxMTGRvLy8Eu4hRN2iKioNoxrQMKoBF9AxbF9BQbn9BUPf8wvJ7XMf4qsj35HhDy98kmRNCBv6fnwIfGPiLDEyT70KbNy4kT179jBy5EjS09NxuVw0bVr7wqji8RD77Q/ErV5DzPc/ovr8+Bomc/Sfo8gacDGelmeB/HsTolbSNA2r9fgoLavVit/vL+MeQgghKlOpYdzlchEIBDAXWR/W7/fj9dbMvuXbP/wTzQ0za16nvqhhCheU6xh/XrH9OQFX2FrqBd9/SP+JFd5VYcfGmKOLDX0/I79nvb4UlDst5syZwy+//MKuXbsYOXIkfr+f+++/P6wHqSZT/H6if/gf8au/JmbdekxuD/6kRNIvH0LmgItxt20tAVzUXLrOlG/9KCaVuWfKv+OyJCYmsnr1avr37w/AqlWrSEhIiHCrhBCi7io1jA8cOJCHH36Yhx9+GEf+cjUul4uZM2cycODAKmugELVRjNnJebElF5TzaN78yu+Hwoa+b8v+gy+PfFOsoNwZ9kbFh747mtDQVh+zKgXlKuLLL79k+fLlDB8+HIDk5GRcLleEW3WKAhrOzVuIX72GuK/XYcrNJRAbQ9aAvmQOvBhXx/Zgkn8fogbTdVSPG1AwzDYMq1k+VCrHo48+yn333ceMGTNQFIWGDRvy9NNPR7pZQghRZ5Uaxu+66y5eeOEF+vbtS5MmTTAMg0OHDjFq1CjuvPPOqmyjEHVKlMlWbkG5wkF9b95B9uYd4Nu0jUUKyploYm/IGfZG/L1eN64/o00VPouaxWKxoChKaJRBTZ6KY/7jDxq8+m+i/7sOS0Ymmt1Odu+/kTXgYnK7dsawWCLdxBonoGtk+DNJ82WS5ssgzZsR+jndl0l6wXZfJigGdjUKp9mJ02THabbjNDlwmh04THaizQ6cJgcOc/Bnh8mRf4w97D5S8LEMmobq9YKiEEhMRI92YmzLkFFCFdCsWTPef//90IeNTqczwi0SQoi6rdQwbjabue+++5g4cSJ79uwBoHnz5kRFRVVZ44QQ4cIKyiWF7wsWlEs73pueX1Rur/sQW7K3R6bBNcSgQYOYNm0a2dnZvP/++yxbtox//OMfkW7WSUl8cDKWbdvI+Vt3Mgf0Ieeibhj5lZPFcT7dFwzU3gzS/ZmkeQsCdeGgHfw5059d4jlsqpUkawKJ1ngaRjXgvNhzcNjsZLgzyQ3kkRdwc9Sbzu7AflyaG1cgD49esWleFsWC02wvPcCb7DjNjrCwH9pmCt9uU621I6hqGqrHAyYTgXqJ6A6HjO44QceOHeP555/nyJEjzJ8/nx07drB582ZGjx4d6aYJIUSdVGoY/+KLL8JuK4pCTk4OrVu3Jjo6ukInX7t2LTNnzkTXdUaPHs2ECRPC9h88eJAHH3yQnJwcNE3jvvvuo0+fPnz88ccsWLAgdNz27dv5z3/+Q5s20rMnRGmCBeXq0zCqfrGCcjbDF6FW1Qzjxo3j22+/xel0smvXLv7v//6vRq4YAXD0zUXkHfwdrzM+0k2pcnmah3Rv0UCdGXY7zZdJui+DnEDJ0xAcJnt+vYcEWjiacn58e5KsCSTZ4kPBO8maQJI1HqfJUSzkxsfFkZmVVeK5IdjLnqe5ydPyyA3k4dLc5AWCP+dpblwBN7mai7yAOxTgXVoeroCbTH82B9yHydPcoeMrwqSoOEyO/CBvLxLcwwN8wXFOkx2HOfw+0SYHdlNU1Qf7gIbq9YDZTKB+PXSnA1S1attQS0yaNIkRI0aE1htv0aIFd999t4RxIYSIkFLD+H//+99i2zIzM9m+fTszZ87koosuKvPEmqYxY8YMFi5cSHJyMqNGjaJfv360bNkydMzcuXMZNGgQY8aMYceOHUyYMIGvvvqKyy+/nMsvvxwIBvHbb7/9tATxfi0T8KbJOuNCiOJ69OhRYwN4YUZMDEZ+nY+azjAMcgKusECdXqz3+vjwcbfmKfE8sebo/ACdwLnRZ5JkPT8YrG3xoe1J1ngSrfHYTZU7+susmohVo4m1VOxD7bLoho5b8+QH87z8IJ+XH+Tz8oN8fqAv9HNBmD/iPYYrdKwbHb3cx1RQigT642E+1ItfaEh+acPwnWYnDlMUJqWMnu1AIDgc3Wwm0KA+usNeagjvcZYdk1V6ycuTkZHB4MGDmTdvHhAcBanKBxtCCBExpYbxJ598ssTtBw4c4K677uKDDz4o88Rbt26lefPmoaWBhgwZwurVq8PCuKIo5OYGw3FOTg4NGjQodp6UlBSGDBlS/jOpgJEd6pG7a5+sMy6ECNO5c+divX0xMTG0a9eOSZMm1colziJFN3Sy/DmFwvXx4eFhvdj5w8cL10EooKAQb4kN9Vh3iGsdCtSFe68T81c0sKi1c568qqj5Q9VP/cMXwzDw6N6SA3xBsA8c79HPyz+mIPyn+7IK9eLnEajgmt9Rqo1oszN8SL4ahVOx4bREY3cm4LDH4syLxmFxBAO9JfjlMDtCPw9o7cAR4wDjlF+KWs3hcJCRcXx+/U8//URMTEyEWyWEEHVXqWG8NE2aNCEQCJR7XGpqKg0bNgzdTk5OZuvWrWHHTJw4kXHjxrF48WLcbjcLFy4sdp5PPvmEV1555USbWSKPX8ejgXLCz1oIUZtdd911NGzYkMsuuwwIfgi4d+9e2rZty5QpU3jrrbci3MLqLaBrZPqzigwHDw/b6flzsjP8WSUGNbNiItEaT2J+qD7L2SwsYB//nkCcJVZWCjjNFEXBborCboqi3imeyzAMfLofV35Qz80P6AU98qHtBT36BeHf7yLPn8ch/SguvLhy3LhSXfj0ik2zGdX6Sl7oNesUW1+7TZo0iVtvvZW9e/fyz3/+k4yMDGbPnh3pZonqTNdRPV5UjwfF7UH1ejEnJGA2dDSnE8MmxSaFOBUnHEv/+usvrNbT84uXkpLC8OHDufHGG9m8eTMPPPAAK1euDA2Z2rJlC3a7nXPOOafcc5lMJpKSkso85uoFG/DmKswZFHda2i9OjMlsIj5OXvtI8OWmk5SYhCWqdgxfPt2++uorPv7449DtK6+8kiuuuIL7778/NLeyrvHr/mI91wU91kWHiWf6szFK6JK0qpZQkG4QVY82sa2K9F4fD9ixlmhURYbL1gaKomAzWbGZrCRa48s/3udD9fnR7TYCCfEYUVFhS5T5dT95/mBYd/ldwTn2/tzgtkBw28e/HGX/gQ6V+KxqPk3T2LBhA4sXL2bXrl0YhsGZZ56JRVZYqNkMA8XnR/V4UN2e4Pf8n5X8EB2+zxt+O/97ice6Pai+kj8Ma5T/XbdY0J0OtGgnWnT08Z+dTvT8bVq0A93pLLL9+M+yyoeoy0oN47fcckuxbVlZWRw9epRnnnmm3BMnJydz+PDh0O3U1FSSk5PDjlm6dCnz588HgsNEvV4vGRkZoVB9IkPUNU0jLS2tzGP8AT+GYZRZXEdUnvIKG4nKYzM00tLTsNjKLvjUqFGjMvfXVna7nU8++YRLL70UgM8++wxbfgXyWlGFOp9b8xwP0d4M0vyZoR7rokXOcgIl19coXOCsuaMJ58e3ze/Nzu+9tiWEwnZ0CQXOhCigeH0ofh+G3Y6vSVIwhJfAolqIs8URZyv9w9zfdhxDMcm/tbKYTCZWrlzJ9ddfT6tWrSLdnLoloJUcdL0eVHehXucStocFbI8Xpdg5vCh6+fUeCtOtVnR7FHpUVPC7zYZuj0KLj8MflXx8X5Tt+DH53xfvMWPTda5smIcpNxdTrgvV5cKUm4fJFfzZticdkysPNdeFyV1+oUndakWLdh4P7IV/djoKhfqC7Y7wsO90gllGS4maqdQwfuONN4bdVhSF+Ph4mjdvXqGe8fbt27N792727dtHcnIyKSkpzJoVPnysUaNGrF+/nhEjRrBz5068Xi+JiYkA6LrOp59+yjvvvHMyz0sIISrsueeeY+bMmTz66KMoikKnTp149tln8Xg8PPzww5Fu3gn5IfVH/vvXco76skn3ZYUF7dKqb8eYo0MB+5zoM0O91QW914m242G7sgucidpP8XpR/H50p5NAcj1Zeq8KnX/++cyYMYPBgwdjt9tD29u2bRvBVlUDuo7i9ZXYY3w8RHuL9CQX6mkuEpgLn0PxeFArML2zMMNkKhSI80OxPQrNYUdPTAjtM0oIy2EhutA2w56/3WY7pSUBv/0ugNlkYmD3Cn74pWmormBQN+W6CoV3VzC855a0PQ/L0WOYcnKDx3jKr/akR9nQ8gO8Hh2Nlt9DH9YjH+M8fkyh7cHbslSiiIxSw3i3bt1K3L5x40ZSUlKYPn162Sc2m5k2bRrjx49H0zRGjhxJq1atmD17Nu3ataN///5MmjSJqVOnsmjRIhRF4amnngr1omzYsIFGjRpJ4SQhRKVr2rRpqcPRu3btWsWtOTUv/PQi3x1aHypwlmiNp13sufnFzsLnXida40i0xmNVZc6fqGSGEQzhmpYfwhvIXNMI+O233wDC5okrisKbb74ZqSadFDUjA9v2HZg8esk9zoWGXCuFt4V6nYsM1/aeWGlfQ1FCgdco0oPsrxddLBQbhYO1veSwXNBDbdijatewbZMJPTYGPTaG4uU4KygQON7T7nLl98jnlR3qc3KxHE7F5MrDlJNb6nD7wjS7PdjbXhDk83vdiw2zjykh7EdHl7nigxClqdCc8V9//ZUVK1bw+eef06RJE/7+979X6OR9+vShT58+YdvuvPPO0M8tW7ZkyZIlJd63e/fuvP/++xV6HCGEOBVer5elS5fy559/4i30pqy0VSWqs8UD38C1bxu6yV7+wUJUNsMIzkXVNQIx0eixsRLCI2j27NmhEYg1WeOhV2A+crTMY3SrJaxn2cgPvFpsLP7kBiUPw87/2cgftl1SWC7Yj0zBqTpmM1pcLFpc7EkHesXvD4V5NTevUKgvMsw+9/h2U2YW1v0HQ6Ff9Zf96IaioDvsx4fQO51oMfmBPaxH3hEM70V65rVoJ7pdAn1dU2oY37VrFykpKaxcuZKEhAQGDx6MYRg1uqrw4DaJeI/KOuNCiHD3338/Z511FuvWreP2229nxYoVnHXWWZFu1kkxqSbMqomK1Z8WopIYRnCILgaBmGgCsbEY1srr7et3jgOTTYaYluarr75iypQpoXXFX3jhBc4///xIN+ukHXl1Lsbvm/DaY473OhcKy7otSuYQV5L+TVUc9iioYQsFGxYLWkI8WkL8SZ9D8fqOB/ZC34sOsw+F+9xcLMfSUffsC/XslzdlwVBVdIcjfL6804kWE43msOMe+ndo1v6kn4OofkoN44MGDaJr1678+9//pnnz5gAsWrSoqtpVKYa0SSI3am8Nu3wIISrb3r17efHFF1m9ejXDhw/nsssuY+zYsZFulhA1j64Hh/waOlpcHFpMNFTBkNt+5ziwOC2yzngp/vWvf/H2229z9tlns2XLFp599lkWL15c4fuvXbuWmTNnous6o0ePZsKECWH7Fy5cyAcffIDJZCIxMZEnnniCJk2aAPDMM8+wZs0adF2nR48ePPTQQ6dc2NHXri2++la8itQbqGoDmqrEx0WRmVX33k0bNisBmxUSE07yBAaKz3d8Lnzh3vj8ofUmV16RUO/CcvQYUbv2oOblYTRrQuDSUaf3iYmIKjWMz5kzh5SUFK699lp69erFkCFDMIya/Vcu0x3A5YMouXYLIQoxm4OXwtjYWP744w/q1atX7uoMQohC9ODcXTCCITw2BswnvHrqScv2aJhVlQSpL1gis9nM2WefDUDHjh1xuVwVvq+macyYMYOFCxeSnJzMqFGj6NevHy1btgwd06ZNG5YtW4bdbuedd97h2Wef5YUXXmDTpk1s2rQptHTkmDFj+PHHH+nevfvpfYKiymR5DfCcWPV2kU9RMGw2AjYbgXplL8dcEkML4LCZcVZC00TklPqXcsCAAQwYMIC8vDxWr17NG2+8QXp6OtOnT2fgwIH07NmzKtt5Wjz06S40N8zsEemWCCGqkyuvvJKsrCzuuusubr31VvLy8sLqWwghSqHrqB43oASHgEY7qzSEF3hmVQaKSeHfI+tV+WPXBGlpaSxcuLDU2zfccEOp9926dSvNmzcPFdQdMmQIq1evDgvjF154YejnTp06hcK3oij4fD78/uDSsn6/n3r15P9RTfbU/zTMpmweq2g1dSFEmcr9i+lwOBg6dChDhw4lKyuLzz77jNdee61GhnEhhChK13WcTidxcXFccMEFrF69OtJNEqL607TgcHRFIZCYiB7tlGWBqrF//OMfYb3hRW+XJTU1lYYNG4ZuJycns3Xr1lKPX7p0Kb179wagc+fOdO/enZ49e2IYBldffXWoh14IIUQFq6kXiIuL48orr+TKK6+srPYIIUSVUlWV+fPnM3jw4Eg3RYjqL6Chej1gMhGol4judErl3xpg4sSJVfI4H330Eb/88ktoPvqePXvYuXMna9asAeDGG29k48aNZS4ZaTKZSEoqewivx2biyFET8bFxp6/xokLMpkwURSE+Tl77qqbrAQyvt9zfD1GzVP1YMiGEqGb+9re/sWDBAgYPHozdfnxJsPj4+Mg1SojqpCCEm80E6tdDdzokhNcRycnJHD58OHQ7NTWV5OTkYsd99913vPrqqyxevBirNbh83ZdffknHjh1xOoOzXHv16sXmzZvLDOOappVbs8Obm4Wua2RmZZ3MUxKnIKBpmE0mee0joGDOeHm/H40aNaqiFonTQcK4EKLO++STTwB4++23Q9sURZEh60IEApg8HnSrhUCD+ugOWQO3rmnfvj27d+9m3759JCcnk5KSwqxZs8KO+fXXX5k2bRrz588P67Vr3Lgx77//PoFAAMMw2LBhA9ddd11VPwUhhKi26lQYH96uHh5ZZ1wIUcRXX30V6SYIUa0ofj+qz4duteBv1BDdHgWnuBxVZbq0jRNTlMxZrwxms5lp06Yxfvx4NE1j5MiRtGrVitmzZ9OuXTv69+/PM888E1b4slGjRrz66qtccsklfP/99wwdOhRFUejVqxf9+vWL8DMSp2JwcxWHww54It0UIWoFxajp65Xl8/l85Q7bMHSd3F2b8SrWKmqVKCw+Lk6GNUWIzfARdUYbLDZHmcfV1aFNbrebhQsXcujQIR577DF2797Nrl276Nu3b6SbFqYi17mAz0Pevm345DoXETX9Oqf4fKh+P7rVipaYUO1DeGEWp4UEIwFVKbvnvi5e5wpXTi9JWdXUq1pFrnPe3Cx8qX/KOuMRUtOvczVVaGmzZu3LPK4uXuNqsjo11iw1x8cRd6RbIYSobiZPnozFYmHz5s1AcI7kCy+8ENlGCVGFFK8P1eUCk4qvUTL+Jo2CQ9JrSBA/lqtxNCcQ6WZUWy6XC5fLxS+//MK7775LamoqqampLFmyhG3btkW6eaIGOeo2SHVpkW6GELVGnRqmPuPLPbLOuKh7AhootWIATKXZu3cvL7zwAikpKQDY7XZqyaAhIcqkeH0ofh+G3Y6/QRJGVFSkm3RSXvi6YJ3x+pFuSrVUUE197NixfPjhh0RHR4e233zzzZFsmqhhnt+sYTblyDrjQpwmdSqMC1FnBAKoPh8YBobFTKBhIpjl1700VqsVj8eDkt8LuHfv3lA1YCFqI8XrRfH70Z1OAsn1MGwy3LcuOHbsWNi1zWq1cuzYsQi2SAgh6jZ5dy5ELaH4/Sh+H4oButVKoF4ihi0Kw2rB4rSALp9il2bixImMHz+eQ4cOce+997J582aefPLJCt137dq1zJw5E13XGT16NBMmTCh2zCeffMKcOXNQFIXWrVuHKhEfPHiQqVOncujQIRRFYd68eZxxxhmn9bkJEWIYwRCuaWjRTvTkBhg2+dCpLhk2bBijRo1i4MCBAKxatYoRI0ZEuFVCCFF3SRgXoqYyjGAADwRQAN1mJVCvHnqUDSyWSLeuRunZsydt27Zly5YtGIbBQw89RGJiYrn30zSNGTNmsHDhQpKTkxk1ahT9+vWjZcuWoWN2797NvHnzePfdd4mLiwsrTPTggw9yyy230KNHD1wuF6osGSUqg2GgeLyoukYgJho9Lg7DKteIusYwDIYNG0bv3r3ZuHEjAE8++STnnXdehFsmagTDIGAE0A0DzVDwan5MmDCpJpRyiiYKIUonYVyImsQwUHx+FC0AGOh2R7Disc0qw9BPwS233MJll11Gv379cDjKrjhf2NatW2nevDlNmzYFYMiQIaxevTosjL///vuMHTuWuLg4gNAavDt27CAQCNCjR7CIhdPpPF1PR4ggw0B1e1AwCMREE4iNlRBehymKwoQJE1ixYgVt27aNdHNEdZYfvIPhWwdAQcGqWjEpKlaTBafFii/gw6t7Q8cAqKioiopJMWFSTDWmCKQQkVKn3r1f1bkB7lRZZ1zUMLoeXPM3EMAA9OhotOjEYAA3ybq6p8ONN97IJ598wqxZs2jfvj2DBw+mb9++2MqZR5uamkrDhg1Dt5OTk9m6dWvYMbt37wbgn//8J7quM3HiRHr37s3u3buJjY1l4sSJ7N+/n4suuoj77rsPk/w/FadK11E9HsBAi4tDi4mu9aNlrmgfLeuMV8B5553H1q1b6dChQ6SbIqoLwyCgBwgQCBUuLQjesZZYbGYbZsWMWTWjKArXtfEQHR1NYtTx1Qs0XUMzgl8BPYBX8+LTfHg0DwYGCkrwu6Jgxiy96UIUUqfCeM8z48gFvJFuiBDl0fXger+ahqEoaDHRBJyOYJElGcp82nXr1o1u3bqhaRrff/8977//PlOmTGHTpk2nfG5N09izZw9vvfUWhw8f5uqrr2bFihUEAgE2btzI8uXLadSoEXfffTcffvgho0ePLvVcJpMp1LNemoDPg++gCUdM3Cm3XZw4k9lEfFyEXntdR/F4MBQwGiajx8bUmREzf08Aj+YhKS6p3HXG67ItW7awYsUKGjdujN1uD21fsWJFBFslqkyR4G0YBqqiYlWtxFnisJqsYcG7JL2aRJGQEENGRkZom0k1YeL4h2ExxOQ/nBEM6bqGhoYv4MOn+/BpPgJGMMwrhgIKod50s2KW3nRRp9SNv9L59mR4yMuFBjGRbokQJdC04BB0XQOTKRjAHfZgAJc/TJXO4/Hw1Vdf8emnn7Jt2zaGDx9e7n2Sk5M5fPhw6HZqairJycnFjunYsSMWi4WmTZvSokULdu/eTcOGDWnTpk1oiHv//v3ZsmVLmY+naVrYnPOSBHweAppGXlZWue0Xp198XByZVf3aaxqq1wMoBBIT0KOdoAA5OVXbjgg6kBnA7DATE0grN4w3atSoilpV/SxYsCDSTRBVxDB0AnoAzdCCPd5KcKpClCmKaHM0FtWCRbVgUkylBu+S7MkOkKF4SajAsYqihMI9gMN8fBqYbuhouhYcDq8H8Gt+vJoXj+4JW1pUUZTg3HTFhKrK6BdR+1RqGC+vyvDBgwd58MEHycnJQdM07rvvPvr06QPA77//zvTp08nNzUVVVZYuXVrukNHyPPPffbLOuKheAhqq3we6DmYzWnwsuj0Kw2qVAF6F7rzzTn7++Wd69uzJ2LFj6datW4WKqbVv357du3ezb98+kpOTSUlJCVVKLzBgwABSUlIYOXIk6enp7N69m6ZNmxIbG0t2djbp6ekkJibyww8/0K5du8p6iqI20jRUrxcUhUBiYjCE19FpDnPXZeavM94g0k2p1po0aQJAWloaXq+ME6wtCgdvIDQkPMoURYw55qSDd0me2piJ2ZzLS73jT+k8qqKimlQsFJ9CE9ADaLqGjo5f9+MNePHpPryB4L9ZGfYuapNKC+MVqTI8d+5cBg0axJgxY9ixYwcTJkzgq6++IhAIcP/99/Pss8/SunVrMjIyMNeRoXaiDggEUH1eMMCwWggkxGNERckSQxE0atQonn/++dB87Y0bN5KSksL06dPLvJ/ZbGbatGmMHz8eTdMYOXIkrVq1Yvbs2bRr147+/fvTq1cvvv32WwYPHozJZOKBBx4gISHYp/Dggw9y3XXXAdC2bdsyh6gLERLI7wk3mQjUS0R3OmX6iqiQ1atX8/TTT3PkyBESExM5ePAgZ599NikpKZFumqigguBdMMzbwMCkmLCZoog1R2FRLZjV473RNVHh9tuxQ/7bo4Jh7wUfPHg1b6iIXFhvOooUkRM1RqX9plakyrCiKOTmBguq5eTk0KBB8BPtb7/9lnPPPZfWrVsDhN64ClFTBdcA96MYBnqUjUC9pNAa4CLyevXqxa+//srKlSv57LPPaNKkCX//+98rdN8+ffqERvQUuPPOO0M/K4rC5MmTmTx5crH79ujRQ+ZqioorCOFmM4H69dCdDgnh4oTMnj2b9957jxtuuIHly5fz/fff8/HHH0e6WaIUev4wbs3QQr3BweBtI9YcWyuC94koOuzdaTm+CokUkRM1VaX99lakyvDEiRMZN24cixcvxu12s3DhQgB27dqFoiiMGzeO9PR0Bg8ezE033VRZTRXi9CtYA9zvRwE0ux0tLjgEva4UVKoJdu3aRUpKCitXriQhIYHBgwdjGAZvvfVWpJsmxHGBACavF91iJtCgfjCES0+POAlms5mEhAR0XUfXdS688EKeeOKJSDdLcDx46+jB4moYmBUzUeYobCbb8aHmMm+6RFJETtRUEU0FKSkpDB8+nBtvvJHNmzfzwAMPsHLlSjRN43//+x9Lly7Fbrdz/fXX065dOy666KJSz1WRKsMWswVdUSJX6baOi2iV4apgGCheL0YgAKqCER+HERODYY+K+DxOj+4hKToJi0l64gsbNGgQXbt25d///jfNmzcHYNGiRZFtlBD5FL8f1edFt9rwN0wOfpgnbxDFKYiNjcXlcnHBBRdw3333kZiYiMPhKP+O4rTS9PA1vAFMigm72R4K3mbVLMH7NJAicqK6q7QwXpEqw0uXLmX+/PkAdO7cGa/XS0ZGBg0bNuSCCy4gMTERgN69e7Nt27Yyw3hFqgyP7ZSE+3BG1Ve6FUCEqgxXtqJLkEU7MZxO9Kj8Jcj8vuBXhFmcFtLS07CoZYfxulZleM6cOaSkpHDttdfSq1cvhgwZEvYHWIhIUHw+VL8f3WrF16ghRpSE8PKM7hyDWdYZL9crr7xCVFQUkydPZsWKFeTk5HD77bdHulm1WknB26yacZgdRJmjQkGxpgTvG86LITomGvBHuimnrKwicoWHvRctImcYRqgQngx7F6eq0sJ4RaoMN2rUiPXr1zNixAh27tyJ1+slMTGRnj17Mn/+fNxuNxaLhQ0bNnD99defcpsuaBZDribrjItTlL8EmaprGKqKFu0kEO0MVkCX+Zs1yoABAxgwYAB5eXmsXr2aN954g/T0dKZPn87AgQPp2bNnpJso6hDF60MJ+DGibPjq54dwUSEdm9iwOC0gn6WVaM+ePRw7dowuXboAoKoqw4cPZ+PGjeTk5EhtntNE0wP4DX8oeCsoWFQLTrOTKMvx4F3e8nvVWbeGNhISosPWGa+NCg97lyJyojJVWhivSJXhSZMmMXXqVBYtWoSiKDz11FMoikJcXBzXX389o0aNQlEUevfuzcUXX3zKbfrjaB7uLDgj/pRPJeoaTUP1+sDIX4IsNpqA0yFLkNUSDoeDoUOHMnToULKysvjss8947bXXJIyLKqF4vSiBALrdTqBBkoTwk7ArzY85z6BLvUi3pHp64oknuOeee4ptj4mJ4YknnuDVV1+NQKtqMMMIDm02AmEBzKJaiLZEh/V41+TgXZI/MvzEaG4a1YyO/NPuRIrI+TRfcNh7CUXkZNi7KKAYtWRMps/nK3eY+m1Lt6O5c5nZQ5aQioQaN0w9EED1+cAwMCxm9JgYdLs9WAG9hgVwi9NCrB4rw9RruIpc5wI+D3n7tuFT5DoXCSdynVO8XhS/Hz06Gi0+FsNmq+TW1V5TVx7LX2e8Tbnhpy5e50aOHMmyZctK3Dd06NBqtapDRa5z3twsfKl/4lWq4HemUPAu3ONtVa3B4mpmGxYlOMf7VNfwrglu/eoYZrP5lNcZr0tOVxE5QwvgsJlxNmv//+3de3RU9d0u8GdfZnIlIYlmgopoX1ApUGUd7YKXAiXc7yDQVqqypKyoRy7qAlQEalmvCl5aUZcoVbEtKksiihB7ug4oQitYtNS8KT1H8ZiaiMQaAglJZjJ77+/5Y8/sZJIQApmZPck8H80imetv7yTfzDO/W4fPl4w1rjvjss5ELdgroDcBUCAeD4yLcrkFGRFFT2ihR9UwYPTKhOXLh6TwjROKrbq6urNe5/f749iSBCdi7+GN5h7vcPDO8mQhRU9xekWTIXhTdERrETnFEqQzuvU4/I5S0lOamqAYBhQAVooXxkUX2QuweRjAiShKRKD4A1AtE0avTBjZ2XyTj+Jm8ODBeOONN/CTn/wk4vLt27dj0KBBLrXKZa2Ct4hAVVR4VS+yPdnwal4Gb4q581pErqkR6R7uftDTMIxT8hGB0hSEYhoABFZqGszcHFgpXu4BTkTRJQLV74diWTCyeiGYncU3+ijuVq1ahcWLF2PXrl1O+C4rK0MwGMSzzz7rcutiT8RyFtwSEUCxexpTtVRk6pnNe3grGoM3JYw2i8jpmchJz0DHkziou2HyoOQgYveAmyYAwEpPh9kr1w7gLu8BTkQ9kGVB9fsBCMzsbJi9MhnCyTUXXXQRtm3bhkOHDuHzzz8HAIwePbrDLWO7q5bBG4CzYFaqlopeei8GbyJKKEkVxu8Yfgkajn/mdjMoXpw9wC2IApiZGbAyM+xFkrgFGRHFgmVBbagHoMDM6Q0zM4MjbuLg5huyuM94JwwbNgzDhg1zuxlREw7e4UWwBAJN0ZCipSJLT4VHtRdWC8/Vpa678wdZ6NWrF7hRMFF0JFV1GtInA2f8LB89WmgPcEVMQFFh9mqxBRkDOBFFk2XZ600YJgCxR+B4PDByc2FlZnDUTRxd4/Nyn/EkYvdoKwhaQaRoKcjSsxi84+QHF3mRk5OOmhq+miaKhqSqWP/9TT0aTgL989xuCUWVYYa2IAvtAZ7dC1Z6GvcAJ6LoELHf6DMMKJY99FURQHQdVkoKzKwUezE2TYeRfzGsU6fcbW8S+j9VTdBTTfwnd/RJCl7Ni/ysvqg1LbebknRKv2tCr0ADruROjERRkVRh/PmDx2E2Ag+PcLsl1GUt9wD3emDk9oakpnbLPcCJKIGYJhTDDC3w2MxKTYHVKxOSkgLRNYiut9/zzfrjiq2Ha6FoCv5zDtN4stBUDWAYj7tNpbXQ9QbuM04UJUkVxql7C+8Brghgeb3cA5yILpxl2Qs6GiYUCb2gD725Z6WlQFKzIB4PRNPsOd8M2URERBRlDOOUuETsAG4YUERgpqXCzOYe4ER0HkQA04JiGvaHKIACiKLASk2FZGZAvF6IrkN0jWtLEBERUdwwjFNiCe8BbgQBBbDS0rkHOBF1jmlCCQ0zh1h2b7YIJMVrryORmgrx6M293UREREQu4qsRcp9lQQkGoRoGBICVmQkzk3uAE9FZtFxQzTSB8AhyTYeVmgozywvxeux53RxiTkRERAkqqcL4spGXovHr/+t2MwhosQe4CVGU5i3IuAc4EbVkhHq7TXu6ioSCdeSCaqEh5nzzLmn9Yng29LSkeklD5Ip7hmajV1YvAH63m0LUIyTVX66rLk7HmTPcZ9wVIvYK6A2N9vBRTbMDeHqaHcDZc0WU3FouqGaZzUPMWy+oFl7FnDWDWrgyz8N9xoni4KocD3Jy0lBTwzBOFA1JFcYPf1WHxn8Dg/Ldbkk3Zll2sBaBEv7cktBqxAJAsfffDb1OVkTs10aqCmRkwMzJhpWWyj3AiZJVeIi509sNQFEgqgorxe7tRih0c0E16qxPvw5ATzUwpm+O200h6tH+eiKAzPoz+H6G2y0h6hmSKoy/8vEJe59xhnE7VIdDdChcN4dq2GEbihOqgVDCVhV7j11Ng3hSIJpq91SpCqBqEFWxXzwrqv25Ev5agZmTA7Omxq0jJqJ4c/bsDi2oBtjB2+uBFZqWIh797Ht2E3XS9iN1UDQFY/pe4nZTiHq0LUfroOuN3GecKEqSKoz3OK1DtCX2C15Bc6i2b2hfhlCPtSiArtlBWlMBTW8O1ZrdE+UE6XCoDgVq9mYTURsiUAzDDt/hETMK7N7t1FSYaeF53VxQjYiIiCiMYTwRiISGfyMiVCuWALDQvFRwaBg4ABH7cydU63ooWNu91pGhWg0NAw2Fag77JKILZYSGl5smFLEn6NpDzL2QjPTmPbs9OmsNERERUQcYxqPJCdXh+dRoE6rt1YCBiFAdCsgRoTo8X1JRI0J1RKBm7xIRxYplhXq7rebpLADE67XXfQjv2R3u7SaiHmv//v14+OGHYVkW5s2bh6Kioojrt2zZgu3bt0PTNOTm5uKRRx7BpZdeCgA4fvw4Vq9ejW+++QaKomDz5s247LLL3DgMIqKEE9NXUOcq3sePH8d9992Huro6mKaJ5cuXY/To0aisrMSUKVNw5ZVXAgCuvfZarFu3LpZNjXQ+i5SJ2KEasENzeD617rWDs7MIUYv51FAYqokoMbTcs9syAcCub7oOy+uFlZXavKCah0PMiZKNaZpYt24dtmzZAp/Ph7lz56KwsBD9+/d3bjNw4EC8+eabSEtLw2uvvYbHH38cTz31FADgvvvuwx133IERI0agvr4eKkfMEBE5YhbGO1O8N23ahMmTJ2P+/Pk4duwYioqK8N577wEALr/8cuzcuTOqbVo5pi8aKo5CbWhwenmivUgZEVHCarmgGkJrTigKJMULKzPD7u3WNS6oRt3OnT/qDT2dIzRiobS0FP369UPfvn0BAFOnTsXevXsjXs8NGzbM+fy6667DO++8AwA4duwYDMPAiBEjAAAZGVyCu7u7//reyMrOAqTB7aYQ9Qgx+8vVmeKtKArOnDkDAKirq0N+fmyXOe+Xm4ZT3ovReMYPXffaIbxlqOYiZUTUQyjBoD2/u8UOCc17dqfYe3ZrGhdUox7h0t469xmPkaqqKhQUFDhf+3w+lJaWnvX2xcXFGDVqFACgvLwcWVlZWLx4MSorKzF8+HAsX74cGt/s67b6ZenI6Z2CmhqGcaJoiFkY70zxXrx4MX7xi19g69ataGxsxJYtW5zrKisrMWvWLGRmZuLuu+/G9ddf3+U2/fnL04A3G1dkq2g0myAQKLCgKio0RYOuqFD5opSIujNFAVK8ELHsBdVSUkKjfLigGvVch//lh5YaxKQruc+4m3bu3ImysjJs3boVAGAYBj7++GO8/fbb6NOnD+655x7s2LED8+bNO+tjaJqGvLy8jp/I74fu9yMnMzOazadOeK+8DtqZeozuy9+1uLMs6JZ17t8P6lZcHdNVUlKC2bNnY+HChThy5AhWrlyJ3bt3Iz8/H++//z5ycnJQVlaGu+66CyUlJcjsoOh2pngX7/wSiqLgD7f9D4gIglYQhmUgYATQGGyE3/TDsAz7xgqgK7od0lUdCkN6l+m6jpwcFm83+C0/8jLz4NE8bjeFYk3TELzsEhj1QbdbQhQ3O//7DBRNwaQrL3W7KT2Oz+fDiRMnnK+rqqrg8/na3O7DDz/E888/j61bt8Lr9QIACgoKMHDgQGeU5NixY/Hpp592+HymaaK6urrjRvn9yDNN1NTUnOfRUFdt/uQ76LqOH2T2drspyceykJORcc7fjz59+sSpQRQNMQvjnSnexcXFePHFFwEAQ4cORSAQQE1NDfLy8pxCPnjwYFx++eX48ssvMWTIkLM+X2eKdzAYhMfjafd2KaH/TMtE0ArCFBONRiNqjVoEzSAkvFe3okBX7ZCuqRxmdT5ycnL4h9MlngwPqk9Ww6N2HMZZwImIqKUhQ4agvLwcFRUV8Pl8KCkpwZNPPhlxm6NHj2Lt2rV48cUXIzpGhgwZgtraWpw8eRK5ubn46KOPMHjw4HgfAhFRwopZGO9M8e7Tpw8OHjyIG2+8EV988QUCgQByc3Nx8uRJZGdnQ9M0VFRUoLy83HlXNdY0tTlkZ3jshUZEBIYYdk+6aaDRaITf8MNv+u3rIU4Puq6wF52IiIh6Bl3XsXbtWixatAimaWLOnDkYMGAANm7ciMGDB2Ps2LF47LHH0NDQgGXLlgGwX989//zz0DQN9913HxYsWAAAGDRoUIdD1ImIkk3Mwnhnivf999+P1atX45VXXoGiKFi/fj0URcHhw4fx9NNPQ9d1qKqKX/3qV+jdu3esmnpOiqLAo3jsXkUdyErJAgBYYjlD3f2GH37Dj0ajMTQXXYFAnIDOXnQiIiLqjkaPHo3Ro0dHXBYO3gDwyiuvnPW+I0aMwK5du2LVNCKibi2mc8bPVbz79++Pbdu2tbnfxIkTMXHixFg2LSpURUWKloIULSWiF90Ue6h70AzCb9o96I3BRihQnPvpis656EREREREREkqqTbl/OXEK+wFxIz6mD2HoihO0E7T05CF5l50wzKcXvSAFYDf8MMUEypUQAFUqHZPuppU3xYiIqIuufvHOdxnnCgOHhqWg+zsbCB4xu2mEPUISfWXy9fLi7zsVFRXxy6Mn42qqPBqXng1L9I96c7l4YDeshe9PljvDHV3tl1TdagKtyUiIiJq7aJMDZ4MnfuME8WYL11DTqYHXI+XKDqSKozv+ewkMjODGHZJ4mzvFO4JT9VT0Qu9ACBi27UmqwmNRiMCRgCmmM79wqu5c8E4IiJKdn/+ohFaahNmDuD2mURRIQKYJmBZgGlCsSxABP/7myDS05swIscARCCqCmgaEP6Xr0mJzktShfEdpd/B4zmNYTOvdLspHVIUpbkXHenondIbAJxt1wzLsOehG43OgnHcdo3IHfv378fDDz8My7Iwb948FBUVtbnNu+++i2effRaKouCaa66J2FnizJkzmDJlCsaNG4e1a9fGs+lEPcb/+mc9FE3BzAFut4SoG2gZtC3LCdpQFIiIvcKRqkJ0HZKSAug6xOMBdB3Ff/sKHk8Qw75/CRTTBJqagGAQSlMTlMZGO6CLOB1FommRYZ2IIiRVGO/uWm67lolMAJHbrgXNoLOqO7ddI4o90zSxbt06bNmyBT6fD3PnzkVhYSH69+/v3Ka8vBybN2/G66+/juzsbFRXV0c8xlNPPYUbbrgh3k2nCxBeoNP5FwJLrIjbeJo8OBM8AxVqm+lGiqI4/xIRxYSIE7Jb9mi3G7Q9HsDjgXi9duAOB+ZweG6PqtofaWkRs0Kk5XMbhv3chhEZ1v3+yMdSlM49J1EPxjDezbXedi07JRsAt10jiofS0lL069cPffv2BQBMnToVe/fujQjjb7zxBn7+85/bC94AyMvLc64rKytDdXU1Ro4cibKysvg2nhymZcKCBUvsDxGJqJVhqhJaZFPTkaamQVd1eFSPE7JVRcXFORfjW/Nb57HC042CVtB50zQc4MOPr0CJeAwGdiI6q3aGjgNoP2inpZ1f0O4qRWl+DqD9sG6agGHYbTcMIBCwg3pTE2AYECW89xDsNrdsN+si9UAM4z0Ut10jir2qqioUFBQ4X/t8PpSWlkbcpry8HADws5/9DJZlYfHixRg1ahQsy8KGDRvw+OOP48MPP4xns5NCZ3qxw0E4XPO8mhce1eOs5XEhAVlTNXg1b4e3scSCKab9JkAosLdcJ8Rv+tu0FYDTDgZ2oh6qvaDdskdbUdoGbU2LDNqJPBRcUQBdt98caHGx83no2J2wHgw2h3W/HzBNO6yHh8C3DP+JfNxEHWAYTyIdbbsWtIIwLdMZ4u43ue0aUTSYpol//etf+MMf/oATJ07g5ptvxq5du/DOO+9g1KhREWH+XDRNi+hZb49hGaivrUdmTmZXm56QLLGae7KtUE92O0toq4oKj2qPGtI13QnZmqpFhtoojwzSdf2c36POCB9ny9DeZDbZvexGEE1WU2RgVwAInOMKH1uy7MKhe07BEgt5eXlJc8zUzYSDZst52q2DtqbZw8bT0iC6bn/euke7J78JF+4J93jaD+umGRnWm5qAUK+6EggAlhXZs94yqHMIPCWopEpWj0z9HnJyciD+OrebklDCvejQ0GbbtaAVhGEa3HaNqB0+nw8nTpxwvq6qqoLP52tzm2uvvRYejwd9+/bFFVdcgfLychw5cgSffPIJXn/9ddTX1yMYDCI9PR3Lly8/6/OZptlmznlrhmXAUA3U1HaffWc66sVuPVQ8/IZieIj4WXuxoQAm7I8gYMFCE5pifix5eXnn/B51hTf0XwYynKHwptih3bLswB6wAs4brIYYzXcW2G+uhsJ6yzclurt7R/eCnu5BdXX1OY+nT58+cWoVJY2Ognaodxu6bvdqp6baYbObBm1XX0uHz5XXe/Yh8KZpLywXmq+uNDVBCQbtrwH7HIdHHLRcWI5hnVySVGG8d5qO3Awvqv3nvi01b7sGHdx2jagdQ4YMQXl5OSoqKuDz+VBSUhKxUjoAjBs3DiUlJZgzZw5OnjyJ8vJy9O3bN+J2O3bsQFlZWYdBvDsKB8WWYTv8Zp4Fywna4Zrh0TxIVVLh0TzQFR2qqkJFqIcXdnhkTWkWDtR6B3/Kw+e+ZWA3xEDQDKLJbELQDMIQo3nueuh74gR2qDEZQRBtWakaPGka9xmn6GsvaMN5b8vWOmi3nqPdg+Y7J+xr6XMNgRdpXlgu3KseDEIJBJp71YHI+ercso3iIKnCeMnRamRmBjD68hS3m9JtdWXbtXQjHUEzCChwXvQpSvO/RN2NrutYu3YtFi1aBNM0MWfOHAwYMAAbN27E4MGDMXbsWIwcORJ/+ctfMGXKFGiahpUrVyInp/vuhSwiTo9sy0XPgMhebAWKE7K9mtfpyQ4PnW7ZK9sTemYTlTM9qROBPfzmSXjqUjiwG2IgEAxEfG9bj5AKfx/dquXvfdYALUXDvIHd93eLXBBedbzlPG20CtqaFhm0vd4eG7Q7o9u+llYUILx6PACk2yNBI+artw7r4Z718JZtaCesc746dZEiIj3ifeSmpqZzDg38n8WfwePxYGOC7zPeU7Tedi0tKw3VJ6vteZ6w53mGP2+zWFEowANwFpdrPS+0ZYiPCPZ22mfgb8GT4UGWlWWvut8BDt9MbJ2pc4Zl4LR6GsH64Hk9dnu92BYsqFCdXmwATi+pR7V7r9mLHSnWw9TdEn4Txulhb7HwXPjDMO0e9nBQBxC3wL5693dQNAUvzBnIYerdXGfqHPx+5NXXoybYQZ1ruZd266AdfukbDtperx3Ukjxod0bSvpZuPV89ELDDejBob+EWDusi9or2sVi93rKQk5GB6tDuLGfDGte9JFXPOMVX623X8jLz4A20v8pwePiq82/Lz1tcZv8vzb1z4UWcYLV7mQULYkr7gb91e0MvHi1YEZe1DvQM/NRdnK0XWyBtQnY4UKdoKXZvtuplLzY5wnPyNXTcAxRedO5sW7sFjPZ72Lm1G503Ebv3stXK486/4S2+UlKcOdptVh7nPGHqrNbz1TPtRVI7nK8eCDTPVw+FdIg0b9mmqvbQeta7pMYwTgkhHGYR43rUqdDf4t9YBX728lMsqYqK+mB9cy+21qoXu50FvPgzRdGgqecO7O1t7dZkNcG0zHa3dmtvSDwDe5LTNCAjA2IYzUE7XntpE7XW2S3bwmE9GLTnq/v99pZtlv36UmkZ1jlfPWkwjFNSiUfoj3Yvv2nZq0s72zm12spJaXUw7QX+LMmK3QFTQtFVHVf0vgLZVjZ7sSkhhd8I6mjaTOvAHl6XJGgFncBuiunUO1PMDufFUw/j8QAFBZC0NLdbQnRu59qyreV8ddNsXlyu5Xx1EfsNyIwMFw6AYol/uYiiLBEDf25WLvy1ibb0KcUKtxuk7q6zgT0c2lO0/wdd8/Dnnoi6H1UFvPY0zrPurx4K68jLAxob491CiqGkCuO/ntkfubm5aKg75XZTiLrkfAN/pjcTASUQ20YREcVRy63dnpp1Nf++E8UBX0u7oOWK7enpDOM9TFK9hZzqUZHm5fYDREREPQn/vhPFB3/XiKIrqXrG3/z038jIbMCk/0h3uylEREQUJfz7ThQf/F0jiq6Y9ozv378fEydOxPjx47F58+Y21x8/fhy33HILZs2ahenTp+ODDz5oc/3QoUPx0ksvRaU9ez+vwR/LqqLyWERERJQY+PedKD74u0YUXTHrGTdNE+vWrcOWLVvg8/kwd+5cFBYWon///s5tNm3ahMmTJ2P+/Pk4duwYioqK8N577znXr1+/HiNHjoxVE4mIiIiIiIhcEbOe8dLSUvTr1w99+/aF1+vF1KlTsXfv3ojbKIqCM2fOAADq6uqQn5/vXLdnzx5ceumlGDBgQKyaSEREREREROSKmIXxqqoqFBQUOF/7fD5UVUUOa1m8eDF27dqFUaNGoaioCKtXrwYA1NfX47e//S0WL14cq+YRERERERERucbVBdxKSkowe/ZsLFy4EEeOHMHKlSuxe/duPPvss1iwYAEyzmNje03TkJeX1+FtPB4PFEU55+0oNnRd57l3Cc89EREREVFiiVkY9/l8OHHihPN1VVUVfD5fxG2Ki4vx4osvAgCGDh2KQCCAmpoafPrpp/jTn/6EJ554ArW1tVBVFSkpKbj55pvP+nymaaK6urrDNm2ceSXy8vLOeTuKDZ5793T23Pfp0ycOrSEiiq7n5l7FvzFEccDfNaLoilkYHzJkCMrLy1FRUQGfz4eSkhI8+eSTEbfp06cPDh48iBtvvBFffPEFAoEAcnNz8dprrzm3eeaZZ5Cent5hECciIiIiIiLqTmIWxnVdx9q1a7Fo0SKYpok5c+ZgwIAB2LhxIwYPHoyxY8fi/vvvx+rVq/HKK69AURSsX78eiqLEqklERERERERECSGmc8ZHjx6N0aNHR1y2bNky5/P+/ftj27ZtHT7GkiVLYtI2IiIiIiIiIrfEbDV1IiIiIiIiImofwzgRERERERFRnDGMExEREREREcUZwzgRERERERFRnDGMExEREREREcUZwzgRERERERFRnCkiIm43goiIiIiIiCiZsGeciIiIiIiIKM4YxomIiIiIiIjijGGciIiIiIiIKM4YxomIiIiIiIjijGGciIiIiIiIKM4YxomIiIiIiIjiLGHDeG1tLZYuXYpJkyZh8uTJOHLkiHPdyy+/jKuvvhonT550LgsGg5g9ezYA4IEHHsDw4cMxbdq0iMc8deoUbrvtNkyYMAG33XYbTp8+3e799+/fj4kTJ2L8+PHYvHlzu+3bsmULpkyZgunTp2PBggX4+uuvo3bsbrvQc//NN9/glltuwZQpUzB16lT87ne/c27Dc985Xfm5BwDTNDFr1izcfvvtzmUVFRWYN28exo8fj7vvvhtNTU3Odd9++y0WLlwIAHjrrbcwYcIETJgwAW+99Va77duwYQMmTZqE6dOn46677kJtbW3Ujj0Zsc65h3XOPaxzyYV1zj2sc+5hnaNOkwS1cuVKeeONN0REJBAIyOnTp0VE5Pjx47Jw4UL58Y9/LNXV1c7tDx48KOvWrRMRkb/+9a9SVlYmU6dOjXjMDRs2yAsvvCAiIi+88II89thjbe5vGIaMHTtWvvrqKwkEAjJ9+nT5/PPP27Tv4MGD0tDQICIir776qixbtix6B++yCz33VVVVUlZWJiIidXV1MmHCBOfc8dx3Tld+7kVEXn75Zbn33nulqKjIuWzp0qWye/duERFZs2aNvPrqq851xcXF8tJLL0lNTY0UFhZKTU2NnDp1SgoLC+XUqVNt2nfgwAEJBoMiIvLYY49FfB/p/LHOuYd1zj2sc8mFdc49rHPuYZ2jzkrInvG6ujocPnwYc+fOBQB4vV5kZWUBAB599FGsWLECiqJE3OfAgQMYNWoUAOCGG25AdnZ2m8fdu3cvZs2aBQCYNWsW9uzZ0+b+paWl6NevH/r27Quv14upU6di7969bR5r2LBhSEtLAwBcd911OHHiRNcPPAF05dzn5+dj0KBBAIDMzEx873vfQ1VVFQCe+87o6s/9iRMnsG/fPuf+ACAiOHToECZOnAgAmD17dsQ5Dd//z3/+M0aMGIHevXsjOzsbI0aMwIEDB9q08Uc/+hF0XQfQs869G1jn3MM65x7WueTCOuce1jn3sM7R+UjIMF5ZWYnc3Fw88MADmDVrFh588EE0NDRgz549yM/PxzXXXNPmPh999BF++MMfdvi41dXVyM/PBwBcfPHFqK6ubnP/qqoqFBQUOJf7fD6nAJ1NcXGx8wvU3UXr3FdWVuKf//wnrr32WgA8953R1XP/yCOPYMWKFVDV5l/rmpoaZGVlOQW3oKDAOaemaeLLL79E//79L+jcv/nmmz3m3LuBdc49rHPuYZ1LLqxz7mGdcw/rHJ2PhAzjhmHg6NGjuOmmm/D2228jLS0NzzzzDF544QUsW7asze2rqqqQnZ3tvLvWGYqiOO9KXcj9w3bu3ImysjIsWrTovO+biKJx7uvr67F06VKsWrUKmZmZbe7Dc9++rpz7999/H7m5uRg8eHCnn+/TTz91/rier02bNkHTNMyYMeOC7k+sc25inXMP61xyYZ1zD+uce1jn6HwkZBgvKChAQUGB84M1adIkHD16FJWVlZg5cyYKCwtx4sQJ3Hjjjfj3v/+N/fv3Y+TIked83Ly8PHz77bcA7IUOcnNzASDi/j6fL2KoRlVVFXw+X7uP9+GHH+L555/Hpk2b4PV6u3TMiaKr5z4YDGLp0qWYPn06JkyY4FzOc39uXTn3f/vb3/Dee++hsLAQ9957Lw4dOoTly5cjJycHtbW1MAwDgD30KXxOL/Tc79ixA/v27cMTTzzRZpgVdR7rnHtY59zDOpdcWOfcwzrnHtY5Oi8uz1k/q5tuukm++OILERF5+umnZf369RHXjxkzxln4YMmSJXLs2LGI6ysqKtos+LF+/fqIRSc2bNjQ5v7BYFAKCwsjFp347LPP2rTvH//4h4wdO1a+/PLLrh9sgrnQc29ZlqxYsUL+67/+q81j8tx3Tld/7kVEDh06FLHgx5IlSyIW/Ni6dauIiPz0pz+Vuro6ERGpqamRMWPGyKlTp+TUqVMyZswYqampafPYH3zwgUyePDli0RG6cKxz7mGdcw/rXHJhnXMP65x7WOeosxI2jB89elRmz54t06ZNkzvvvLPNSoDhH2LDMGTmzJkR191zzz0yYsQI+f73vy8jR450VjM8efKk3HrrrTJ+/HhZsGCB1NTUtHv/ffv2yYQJE2Ts2LHy3HPPOZc/9dRTsmfPHhERWbBggQwfPlxmzJghM2bMkNtvvz36J8ElF3ruDx8+LFdddZVMmzbNOS/79u0TEZ77zurKz31Y6+L91VdfyZw5c2TcuHGyZMkSCQQCUl1dLbfcckvE/bZv3y7jxo2TcePGSXFxsXP5qlWrpLS0VERExo0bJ6NGjXLO/Zo1a6J05MmJdc49rHPuYZ1LLqxz7mGdcw/rHHWWIiLidu98V3z88cd45513sG7dOlfun8x47t3T1XO3c+dOVFVVoaioKMoto1jg75p7eO7dwzqXXPi75h6ee/ewzlG3D+NERERERERE3U1CLuBGRERERERE1JMxjBMRERERERHFGcM4ERERERERUZwxjBMRERERERHFme52A6h7GDhwIK666irn66lTp0Zt5cbKykrccccd2L17d1Qej4joQrDOEVFPxzpHlFgYxqlTUlNTsXPnTrebQUQUM6xzRNTTsc4RJRaGceqSwsJCTJo0CQcOHEBKSgqefPJJ9OvXD5WVlVi1ahVqamqQm5uLRx99FJdccgm+++47/PKXv0RFRQUA4KGHHkJ+fj5M08Tq1atx5MgR+Hw+PPfcc0hNTcXvf/97bNu2DZqmoX///vjNb37j8hETUbJhnSOino51jsglQtQJ11xzjcyYMcP5KCkpERGRMWPGyHPPPSciIm+99ZYUFRWJiMjtt98uO3bsEBGR7du3y5133ikiIsuWLZMtW7aIiIhhGFJbWysVFRUycOBAOXr0qIiILF26VN5++20RERkxYoQEAgERETl9+nR8DpaIkhLrHBH1dKxzRImFC7hRp4SHNYU/pkyZ4lw3bdo0APa8o7///e8AgCNHjjiXz5w5E5988gkA4NChQ5g/fz4AQNM09OrVCwBw2WWXYeDAgQCAQYMG4euvvwYAXH311Vi+fDl27twJTdNif6BElLRY54iop2OdI0osDOOUELxer/O5pmkwTRMAsHnzZsyfPx9Hjx7F3LlzYRiGW00kIuoS1jki6ulY54jOD8M4ddkf//hHAMC7776LoUOHAgCGDh2KkpISAMCuXbtw/fXXAwCGDx+O1157DQBgmibq6urO+riWZeGbb77BsGHDsHz5ctTV1aGhoSGWh0JE1C7WOSLq6VjniOKPC7hRp/j9fsycOdP5euTIkVi+fDkA4PTp05g+fTq8Xi9+/etfAwDWrFmDBx54AC+99JKz4AcAPPjgg1izZg3efPNNqKqKhx56CBdffHG7z2maJlasWIEzZ85ARHDrrbciKysrxkdKRMmKdY6IejrWOaLEooiIuN0I6r4KCwtRXFyM3Nxct5tCRBQTrHNE1NOxzhG5g8PUiYiIiIiIiOKMPeNEREREREREccaecSIiIiIiIqI4YxgnIiIiIiIiijOGcSIiIiIiIqI4YxgnIiIiIiIiijOGcSIiIiIiIqI4YxgnIiIiIiIiirP/D+b0mYpwX0o+AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1080x288 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "performances_df_nn_subset = performances_df_nn[performances_df_nn['Parameters'].apply(lambda x:x['clf__lr']== 0.001 and x['clf__module__hidden_size']==500 and x['clf__module__num_layers']==2 and x['clf__module__p']==0.2 and x['clf__batch_size']==64).values]\n",
    "summary_performances_nn_subset=get_summary_performances(performances_df_nn_subset, parameter_column_name=\"Parameters summary\")\n",
    "indexes_summary = summary_performances_nn_subset.index.values\n",
    "indexes_summary[0] = 'Best estimated parameters'\n",
    "summary_performances_nn_subset.rename(index = dict(zip(np.arange(len(indexes_summary)),indexes_summary)))\n",
    "get_performances_plots(performances_df_nn_subset, \n",
    "                       performance_metrics_list=['AUC ROC', 'Average precision', 'Card Precision@100'], \n",
    "                       expe_type_list=['Test','Validation'], expe_type_color_list=['#008000','#FF0000'],\n",
    "                       parameter_name=\"Epochs\",\n",
    "                       summary_performances=summary_performances_nn_subset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optimal number of epochs also depends on the metric and has a sweet spot strongly connected to the choice of other hyperparameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+MAAAEoCAYAAAAzNCCOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAADAd0lEQVR4nOzdd3wU1drA8d/M7G4qqUCoofcuCHoBURCRplRRLKgUG14rCqigKHZ8RbEhCF5RQUBRiB2vioqFCxqpAhJCDZBets7M+8cmS0IqmGRTnq+f/WR3dmb37EpO5pnznOcopmmaCCGEEEIIIYQQotKo/m6AEEIIIYQQQghR20gwLoQQQgghhBBCVDIJxoUQQgghhBBCiEomwbgQQgghhBBCCFHJJBgXQgghhBBCCCEqmQTjQgghhBBCCCFEJZNgXAghhKgB2rVrx+eff16mfWfOnMktt9xSwS0SQpyLESNG8PLLL/u7GYV8+OGH9OjRo8z7n02fJERtpcg647XTjh07GDduHN26dWPlypUFnjt8+DCDBg1izZo1dOnSpcBz119/PW3atGHOnDm+bbt27eKNN97gt99+Iz09nYYNG9KzZ09uuukm2rVrV+T7z5w5k48++ggATdOoX78+AwYM4N577yU8PLzAvn/88QevvfYaW7duJScnhyZNmjBixAimTp1KQEBAgX3PpS1CiIpTUl8jytfJkycJDw/HZrOVum9mZiamaRIWFlYJLROiejt16hSvv/463377LcePHycyMpJ27dpx/fXXM2DAgHJ/vxEjRjBkyBDuvPPOIp//8MMPmTVrlu9xvXr16NmzJ/fffz9NmzYt9/bkcTgcZGdnEx0dXab9z6ZPOltut5uPP/6Yzz77jL179+J2u2ncuDGXXHIJ119/faG+7bfffmPp0qXs2LGDEydO8NRTTzFmzJgC+5imyaJFi1i1ahUZGRl069aNOXPm0KZNG98+6enpPPHEE3zzzTcADBw4kEceeUT6UnHOZGS8llq9ejUTJ05k79697N+//5xf57///S/jx48nJyeHZ599ls8++4wXXniBevXqsWDBghKP/de//sUPP/zAN998wxNPPMF///tfHnvssQL7bNy4kWuvvZbIyEiWLVvGF198wfTp01m1ahU333wzLperXNoihKgY5dXXlJXb7a7w9yhv+fuxf6JevXplPumtU6eOnDwKUQaHDx9m9OjR/PDDD9x777188sknLF++nIsvvpi5c+ee8+sahoGu6+d8fFBQED/88AObNm3i+eefZ/fu3dx+++3FvmZ59I2BgYFlDsTh7Pqks3H48GHGjRvH8uXLueSSS3jhhRdYvnw5t9xyC3v27GHo0KFs27atwDE5OTm0bduWhx56iMDAwCJf98033+Stt97ikUceYc2aNURFRXHTTTeRlZXl2+e+++5j586dLFmyhCVLlrBz504eeOCBcv+MohYxRa1jt9vNnj17mrt37zZnzZplPv300wWeP3TokNm2bVszPj6+0LHXXXed+dhjj5mmaZo5OTlmnz59zFtuuaXI90lPTy+2DQ8++KA5bdq0Atueeuops3fv3r7Hea9/2223FTp++/btZrt27cw333zzH7dFCFExSupr7r33XnP69OkF9td13bzooovMt956yzRN0zQMw1y8eLE5aNAgs0uXLuaIESPMdevW+fbP66vWr19vXn/99WaXLl3Md955x0xJSTHvueces3///maXLl3MYcOGmWvWrCnwXtnZ2eaMGTPM7t27mxdeeKH5+uuvm9OmTTMffPBB3z5Op9N89tlnzf79+5tdu3Y1x4wZY37//fclfubrrrvOfOSRR8zHH3/c7NWrl9mrVy/z6aefNnVd9+1zySWXmC+99JI5c+ZMs2fPnuadd95pmqZp/u9//zOvvfZas2vXrma/fv3MOXPmmJmZmb7jDMMwly5dag4ePNjs1KmT2b9/f/P555/3Pd+2bVvzs88+8z1++eWXzYsvvtjs1KmT+a9//cucMWOG77kz+2Cn02k+8cQT5oUXXmh27tzZHD9+vPnbb7/5nv/555/Ntm3bmj/99JM5btw4s2vXrubo0aPN7du3l/h9CFHdTZkyxezXr5+ZlZVV6Ln85xZvvfWWOWLECLNbt25mv379zNmzZxd4fu3atWb37t3Nb7/91hw+fLjZoUMHc8+ePeapU6fMW2+91ezSpYt58cUXm6tXrzaHDx9uvvTSS8W2Ke+18vv444/Ntm3bmvv37/f9vn777bfm2LFjzU6dOpnffPNNqX2qaZrm8ePHzXvvvdfs3bu32bVrV/OKK64wN2/eXOT7Hj161Lz11lvN888/3+zatas5ZMgQc8OGDb7nz+yTdu/ebU6aNMns0qWLef7555sPPvigmZGR4Xs+r19avny52a9fP7NXr17mzJkzzZycHN8+mZmZ5mWXXWYuWLDANAyjyO/n66+/Nv/1r3+ZSUlJRT7fvXt3c+3atQW2GYZh9u3b13z11Vd92+x2u9m9e3fz/fffN03TNPft22e2bdvW3LJli2+f3377zfe9C3EuZGS8Fvr8889p1KgR7dq148orr2TdunXndMX0hx9+IDU1lWnTphX5/NmMuhw6dIhNmzZhsVgKvf6UKVMK7d+pUycuvPBCNmzYUO5tEUKUj5L6miuuuIJvv/2WzMxM3/6//vorJ0+eZPjw4QC8+OKLrFmzhjlz5hAXF8e0adOYO3cu3377bYH3eeGFF5g4cSJxcXFceumluFwuOnbsyBtvvEFcXBw33HADc+fOZfPmzb5jnn76aX777TcWLVrE22+/ze7du9myZUuB1501axa//fYbCxYsYMOGDYwePZrbbruN3bt3l/i5169fj2marFy5kscee4wPPviAt99+u8A+y5Yto2XLlqxdu5Z7772XPXv2MHnyZAYOHMjHH3/MokWL2L17N7Nnzy7wOV999VWmTZtGXFwcCxcupEGDBkW24YsvvuCtt95i7ty5fPnll7z++ut07dq12DbnZRM9+eSTrFu3jrZt2zJ16lROnDhRYL8FCxZw33338eGHHxIZGcn999+PKbPdRA2VlpbGpk2buPbaawkJCSn0fP5zC0VRmD17Nhs2bGDBggXEx8fz+OOPF9jf6XTy6quv8thjjxEXF0ejRo2YOXMmiYmJLFu2jFdeeYWPP/6YI0eOnHVb80Z7PR6Pb9vzzz/P3XffzWeffUa3bt1K7VNzcnK4/vrrOXLkCK+88grr16/njjvuKPY9H3vsMRwOB//5z3/YsGEDs2fPpk6dOkXum5OTw+TJkwkODmb16tUsWrSIbdu2FejjALZs2cLevXtZvnw5//d//8dXX33Ff/7zH9/zS5YsoUOHDtx7771kZ2czc+ZM+vXrx+jRo/nwww8ZPnw4gwYNYvz48bz66qtl/v4OHz7MyZMn6du3b4Hv9Pzzz/eNsm/bto3g4GDOO+883z49e/YkODi40Ei8EGVlKX0XUdOsXbuWK6+8EoDevXsTFBTExo0bufzyy8/qdRISEgBo1arVObVj06ZN9OjRA13XcTqdAAXmQB04cKDE12/VqhWrV68ul7YIIcpfSX1N3759qVOnDp9//jnjx48HvEHsBRdcQP369cnJyWHZsmW89dZb9OrVC4CmTZsSHx/Pu+++y8UXX+x7n+uuu65Q/5X/It6ECRP4+eef2bBhAxdeeCHZ2dl8+OGHPPPMM74Tr/nz5xeY+5mYmEhcXBzffPMNjRo18r3PTz/9xMqVK3n00UeL/dz169fn4YcfRlEUWrVqRUJCAsuWLeOmm27y7dO7d2+mTp3qe/zAAw8wdOhQbr75Zt+2Rx99lFGjRpGcnExgYCDLly9n9uzZjBs3DoBmzZoVW0zp6NGj1KtXj759+2K1WmnUqFGhGiB5cnJyWLlyJU888YTve33sscf4+eefeffdd7nnnnt8+951111ccMEFANx+++1MnDiRpKSkYi8KCFGdJSYmYppmmc4tbrzxRt/9Jk2aMGPGDG6//XaeeeYZVNU79qXrOo888gidO3cGvOc533//Pe+99x49e/YEvBcKL7300rNq5/Hjx1m6dCkNGjSgefPmpKamAjB9+nT69esHUKY+dcOGDZw8eZKVK1cSFRUFQGxsbLHve+TIEYYMGUL79u19r1ecDRs2YLfbefbZZwkNDQVg3rx53HDDDRw8eJBmzZoBEBoaymOPPYamabRq1YrLL7+czZs3+wpOrlu3jsWLF/u+q/379/PSSy/hcDh47LHHfBd8x4wZw8SJE0vsq/M7efIkAHXr1i2wPTo62ndR8tSpU0RFRaEoiu95RVGIiori1KlTZXofIc4kwXgtc/DgQf73v//x/PPPA95OZOTIkaxZs+asg/F/OhrSq1cvHn/8cRwOB6tXryYxMZHrr7/+nF5LRmaEqFpK62ssFgvDhg1j/fr1jB8/HpfLxZdffslDDz0EwL59+3A6nUyZMqXAiU9ekZ788k5s8+i6zuLFi/n00085ceIELpcLt9tN7969AW8mjtvtLjBSHBwcXKBIz44dOzBN0zdKn8flcvmC0eJ069atQJt79OjBwoULycrK8p2EntnmHTt2cPDgQT777DPftrx+LTExEU3TcLlcXHjhhSW+d57LL7+c//znPwwaNIh+/frRv39/Bg0aVOT8zcTERNxud4HRHk3T6N69e6F5/vkLYdavXx+A5ORkCcZFjXQ25xabN29m8eLF7N+/n8zMTAzDwO12c/LkSWJiYgCwWCx06NDBd8z+/ftRVbVAX9S4cWPf71ZJcnJy6NGjB6ZpYrfb6dSpEy+//HKB3/H8/UxZ+tSdO3fSrl07XyBemhtuuIFHH32UTZs2ccEFFzB48OBCfVv+z9quXTtfHwjevlFVVfbt2+cLxlu3bo2mab596tevzx9//AF4i6dlZmbStm1bwFtXaNGiRb6+6/bbb2fhwoWAd756WlpamT6HEP4kwXgts3r1anRd55JLLvFty/tjc+zYMRo2bOjrKPMXrMiTkZHhS0Fq0aIF4O1g85/ElVVQUJCv83344Ye5/vrrefXVV33VQ/Nef9++fb4rxvnt37+f5s2bl0tbhBDlqyx9zRVXXMGECRNISkrijz/+wO12M3jw4AL7vvbaa76R6Tz5p7OAty/Jb+nSpSxbtozZs2fTrl07goODeeGFF0hJSSlz+03TRFEU1qxZU+j9iiv+czbObLNhGIwfP77A6FqemJgY/vrrr7N6/YYNG/L555+zefNmfvrpJ5555hleeeUVPvjgA4KDg8v8OvlP2qHgd5/3nGEYZ9U2IaqLZs2aoSgK+/fv9/VNRTly5Ai33HILV111Ff/+97+JiIhg586d3HvvvQWmAdpstgKBZp4zf8/KIigoiHXr1qGqKtHR0UX+XufvZ86mTy2r8ePH079/f7777jt++uknrr76am655ZZiq8AXJ//nP7MtiqL42u7xeApcbHC73QU+d/6pBDt27PCdY5ZFvXr1AO/od/7vJzk52TdaXrduXVJSUnx/H8D7vaakpBQaUReirGTOeC3i8XhYt24d9913H+vWrfPdPv74Y9q1a8fatWsBiIiIIDIyku3btxc4Pisri8TERF/g27dvXyIjI33pQmfKyMg4q/ZNnz6dN998k6SkJN/rR0REsHTp0kL77tixg82bNzNy5MgKaYsQ4tyVta/p2rUrsbGxbNiwgfXr1zNo0CDfyVSrVq2w2WwcPXqUZs2aFbidOTJ+pq1bt3LJJZcwatQoOnToQGxsrG8qC3hTKa1WK3/++advm91uZ+/evb7HHTp0wDRNTp48Wej980a5ivPHH38UGFH7/fffqV+/foERoTN17NjRNzp05i0wMJCWLVtis9kKzHsvTUBAABdffDGzZ89mzZo17N27l61btxbaLzY2FqvVWuA5Xdf5/fffZeqPqNUiIiLo168fK1asIDs7u9DzeecW27dvx+12M2vWLHr06EGLFi0K1VsoSsuWLTEMg/j4eN+2o0ePlulYRVFo1qwZTZs2LdMFtrL0qR07dmTPnj1ndeGyQYMGTJgwgYULF/Lvf/+bVatWFfv+f/31V4GBnm3btmEYRpn7mcjISDwej+/76dWrF4sXLyYnJ4fU1FRfbY69e/fy2GOPMXny5DJ/jiZNmlCvXj1++ukn3zan08mWLVt804F69OhBTk5Ogfnh27Zt82UpCHEuJBivRb799ltSU1MZP348bdu2LXAbNmwYH374oe8E8qabbuLNN9/k448/JjExkfj4eO6//34iIyN96ezBwcE88cQT/PDDD0ybNo0ff/yRw4cPs2PHDl588UXuv//+s2pfnz59aN26Na+99lqB1//uu++YNWsWO3fu5OjRo8TFxXHbbbfRs2dPbrjhhgppixDi3J1NXzNy5EhWr17Nt99+yxVXXOF7jdDQUG6++WaeffZZ1qxZw8GDB9m1axfvv/9+sSd7eZo3b87mzZvZsmUL+/fvZ968eRw+fNj3fEhICGPGjOH5559n8+bN7Nu3j4cffhjDMHyjHS1atGDkyJHMmjWLzz//nEOHDvHnn3+ydOlSvvzyyxLf/8SJE8yfP5+///6bzz//nKVLlxY54p3f1KlTiY+PZ86cOezcuZODBw/y3//+lzlz5vi+jxtuuIEXXniBtWvX+vrl9957r8jX+/DDD1m9ejV79uzh0KFDfPjhh1it1iJHioKDg7nmmmt4/vnn+e6779i/fz+PPvooycnJTJw4scR2C1HT5S1fNnbsWD777DP+/vtv9u/fz3vvvefrs5o1a4ZhGLz99tscOnSIDRs2FCraWJSWLVvSv39/5s6dy7Zt29i1axczZ84sl+ybM5WlTx0xYgTR0dHcfvvtbNmyhUOHDrFx40Z+/vnnIl/ziSee4Pvvv+fQoUPs2rWLTZs20bp16yL3HTlyJIGBgTz44IPs2bOH3377jTlz5nDZZZeVeQRbVVUGDRrEu+++C8BDDz3E/v376dmzJwMHDuS8887jyJEjTJkyheuuu67AOuLZ2dns2rWLXbt2YRgGR48eZdeuXRw9ehTwXty44YYbePPNN/nyyy/566+/mDlzJsHBwYwYMQLwXlDI//9r27ZtzJ07l0suuYSWLVuW7X+EEGeQNPVaZM2aNfTp04fIyMhCzw0dOpQFCxbw448/0q9fP6ZMmUJwcDBLlizh8OHD1KlTh549e/Kf//ynwB+JSy+9lJUrV7J48WJmzJhBRkYGDRo0oFevXsyYMeOs23jTTTcxa9Yspk6dSuPGjRk8eDArVqzg9ddfZ9KkSdjtdho3bsz48eOZNm1agXSl8m6LEOLcnE1fc+WVV/Lyyy8THR1doIotwN13303dunV56623ePTRRwkNDaVDhw5FrrCQ32233cbhw4eZOnUqgYGBjB49mpEjRxaY//zggw9it9u57bbbCA4O5sYbb+TUqVMF+pSnnnqK119/neeee46kpCTCw8Pp0qULffr0KfH9R44ciWEYXHXVVSiKwrhx40oNxtu3b8+KFSt48cUXue666zAMg6ZNmxYo5HTfffcRHh7Oq6++SlJSEtHR0YwaNarI1wsLC+PNN9/kmWeewePx0KpVK15++eViCyzl9ZGzZs0iIyODjh078uabb5Zp7qoQNVnTpk358MMPeeONN3j++edJSkoiIiKC9u3bM2/ePMD7+/vQQw/x5ptv8uKLL9KjRw8eeOCBAsUPi/P000/z8MMPM2nSJCIjI5k+ffpZjUyfjdL61ODgYFasWMHTTz/NrbfeitvtpkWLFgWK6+ZnmiZPPPEEx44dIyQkhAsvvJCZM2cWuW9QUBBLly7lySefZPz48QQEBDBo0CBfnZCyuuOOOxg3bhxdunTh0ksv5ZNPPuHUqVOEhoZisVi4/vrri0wZ3759u28AB+Dll1/m5ZdfZvTo0Tz99NOA96Ko0+lk3rx5pKen061bN956660CWU0LFizg8ccf9426Dxw40HfRVIhzoZhS+UoIIUQt53K5uOSSS5g8eXKBiuZn6/rrr6dNmzZyciaEEBXk559/5q677mLIkCFcc801tG3bFlVVOXDgAO+++y6nTp3yFXIToqqTkXEhhBC1zs6dO9m/fz9du3YlOzubN998k+zsbIYNG+bvpgkhhCjBBRdcwLp163j11Ve58cYbycjIQFVVQkNDGTFiBI888oi/myhEmUkwLoQQolZatmwZBw4cwGKx+NLEZYkuIYSo+ho2bMjjjz/OY489RkpKCrquU69ePd+a7kJUF5KmLoQQQgghhBBCVDK5fCSEEEIIIYQQQlQyCcaFEEIIIYQQQohKJsG4EEIIIYQQQghRySQYF0IIIYQQQgghKpkE40IIIYQQQgghRCWTYFwIIYQQQgghhKhkEowLIYQQQgghhBCVTIJxIYQQQgghhBCikkkwLoQQQgghhBBCVDIJxoUQQgghhBBCiEomwbgQQgghhBBCCFHJJBgXQgghhBBCCCEqmQTjQgghhBBCCCFEJZNgXAghhBBCCCGEqGQSjAshhBBCCCGEEJVMgnEhhBBCCCGEEKKSSTAuhBBCCCGEEEJUMgnGhRBCCCGEEEKISmbxdwPKi67r6Lpe6n6appVpP1H+5Lv3n7J+9zabrRJaI86V9HNVn3z3/iP9XM0g/VzVJ9+9/5Tlu5c+rnqpUcF4cnJyqftFR0eXaT9R/uS795+yfvcNGzashNaIcyX9XNUn373/SD9XM0g/V/XJd+8/ZfnupY+rXiRNXQghhBBCCCGEqGQSjAshhBBCCCGEEJWsQoPx77//niFDhjB48GAWL15c6PkjR44wadIkRo4cyfXXX8/x48d9z02ePJlevXpxyy23VGQThRDiHymtn3vyySe58sorufLKKxkyZAi9evUCYNeuXUyYMIHhw4czcuRIPv3008puuhBCCCGE8KMKmzOu6zrz5s1j2bJlxMTEMG7cOAYOHEjr1q19+zzzzDOMGjWK0aNHs3nzZhYsWMBzzz0HwJQpU7Db7axataqimiiEEP9IWfq52bNn++6/88477Ny5E4DAwECeeeYZmjdvTlJSEmPHjqVfv36EhYVV+ucQQgghhABwu90kJibicDj83ZQaIzAwkNjYWKxWa6HnKiwYj4+Pp1mzZjRt2hSA4cOHs3HjxgInqfv372fWrFkAXHDBBdxxxx2+5y688EJ++eWXimqeEEL8Y2Xp5/KLi4vjzjvvBKBFixa+7TExMURFRZGSkiLBuBBCCCH8JjExEU3TqF+/Poqi+Ls51Z5pmmRnZ5OYmEirVq0KPV9haepJSUk0aNDA9zgmJoakpKQC+7Rv354vv/wSgK+++ors7GxSU1MrqklCCFGuytLP5Tly5AiHDx/mggsuKPRcfHw8breb2NjYCmurEEIIIURpHA4HISEhEoiXE0VRCAkJKTbTwK9Lmz3wwAM8/vjjfPTRR/Tq1YuYmBg0TTun19I0jejo6FL3s1gsZdpPlD/57v1Hvnv/i4uLY8iQIYX6uBMnTjBjxgyeeeYZVLXk66PSz1V98t37j3z3QghRPiQQL18lfZ8VFozHxMQUKMiWlJRETExMoX0WLVoEQHZ2Nl9++eU5p2jKupRVn3z3/iPr71aMsvRzeT799FPmzJlTYFtWVha33HIL99xzD927dy/1/aSfq/rku/cf6eeEEKLqSk9P59///jcAKSkpqKpKREQEAEuWLClyPnVlWLVqFVdeeSWBgYF+ef8KC8a7dOlCQkIChw4dIiYmhri4OBYsWFBgn5SUFCIiIlBVlcWLFzN27NiKao7wM6fu5ET2CVLtqdhUGxbVgqqoaKqGpmioiqyyJ6qfsvRz4K2PkZGRQY8ePXzbXC4Xd9xxB1deeSWXX355ZTZblIVpgmF4f55xX8nblrfd4/H+1HVwu723oCCQkQUhRA2T48nBleUiNTvVd+6mKApq7sxXVVVP31dU34igggK5XaKS+1/esWfeL+45Ub2Fh4fz9ttvA7B06VKCgoKYOHGin1sFH3zwAUOGDKl5wbjFYmHOnDlMmTIFXdcZO3Ysbdq0YeHChXTu3JlBgwbx66+/8sILL6AoCr169WLu3Lm+4ydOnMjff/9NTk4OF110EfPnz6d///4V1VxRQZy6k1RHKpmuTOpZ6pHlysIwDUxMFBRMTMDbYVtUCzbVhlW1YtNsqKqKpmi+m3TEoqopSz8H3lHxYcOGFfg3/Nlnn7FlyxbS0tL46KOPAHj66afp0KGDXz5LtXdmgHzGfQW89/Nuuu67r+QF06aJkrc9/0vnvr6SN43AME4H2oqCqSjex4oCOTlop06BpmGEh2OGhIDNVolfhBBClD+n7uSU/RR2t536tvo4dafvHM40Td/9Ih/nnvPlPvD9Lcy/T1nkBf8qKop6Osgv6UJA3n+qqp6+n+8ignL6CkGpFwny3i//BQY5Nz13TqeTcePGsXLlSiwWC9nZ2UyaNImVK1dy991307p1a7Zt24au68yePZuOHTtit9v5v//7P/7++288Hg+TJ08uFB+eOnWKOXPmkJ2dja7r3H///XTv3p1ffvmFpUuX4na7ady4MbNnzyYuLo5Tp05x5513Eh4e7svYrkyKaZpn95tQRblcLknfrELyB+FW1UqgJZDIyMhiC/SZpolu6him4ft5Jk3RvAG75g3YrapVAvYz5Y7SKR6Pd3TO4UBxOokMDyc5JAQsJV9/k/TNqq3G9XNlHX3OC5bzBdFK7n0l7zhdPx0gm6Y3QMY3EHP6/VTV9xyqejqIzn8rZe5+SXz9nK6juFzg8WCGhGBGRGAGBv6j1xYlkzT1mqHG9XPVnNtwk+pIJd2Zjk2zEaAFlHg+V5HyQhYTs+D9vKDePB3gn7nPmccXRcn3F+NcLhTkXQhQ1NPBu4rqqwejonovEuRmCajkXjDIzSzwXTw4I5sg/4WA+nXrk5GWUWJb/mkft2PHjmKn3JWXvJHxAwcO0L9/fy666CI+/vhjEhMTufPOO5k+fTpNmjRh5syZ/P777zz//POsWLGC119/nRYtWjBkyBAyMzOZOnUqy5YtIygoyPfa77//Pi6Xi0mTJqHrOg6HA7fbzezZs1mwYAFBQUGsWLECl8vFzTffzNixY1m6dKkvZb6iJCUl0alTp0Lb/VrATdQ8ZwbhdWx1ynScoihYlJL/OeYF6naPnWwz2xuwm2Aq3g5TwfsavoBdyw3YlXwBu3puBQKrnNx0WEXXwekEpxM178Sf3ABEUTA1zRuAezzeQESIf+JsR5/z/t2VNPpsmt5/q7n3yzT6nLePqmLmD6iLanIFfh0l0jTMvJMDlwv12DFQVYywMMzQUAgI8FfLhBCiVLqhk+ZMI82ZhqqoZT6fq0hFpbxXFfmzAfLfNzAwdKPEiwRnHnOmvGDcxMQd4KYO/v9/UV5GjhzJu+++y0UXXURcXBwzZ870PTd48GAAunfvTk5ODpmZmfz666/88MMPvPfee4D34l1SUhLNmzf3HdehQweefPJJPB4P/fv3p23btvz4448kJCRw6623AuDxeOjcuXPlfdASSDAuysW5BuFnQ1XUUueW64Z3VD3bnY3hMgp1bAoKFs3iG1mv0vPX80YEPR5v8JI7yq24XGAYvqDbVFWwWDCtVt8JvoTdwqeqjT6rKqbFUuwIcY38t2uzYdps3u80IwMlNRUCAjAjI70B+zmuIiKEEOXNMA0yXZkk25NBgWBLsGQdlsGZKe8VwTCNIjNHq7OuXbuyYMECtm7dimEYtGzZsth98/4dzp8/n2bNmhW7X/fu3XnllVfYvHkz8+fP5+qrr6ZOnTqcf/75PPbYY+X+Gf4pCcbFP1IZQfjZ0FQNDQ0rRVdkNE0TwzTw6B6cHmfVmL+eN4KYl17udKI4HChud4HRbFPTvKNtgYG+gKhGBi7in9F1OHQILSmp9NHn/NkSxY0+a1rB7UWQf4dlpKrewm4Abjfq8eOFR8vlpFcI4QemaZLtzuaU/RS6qRNkCao6gxOiRrv88st59NFHuemmmwps37hxIz179uSPP/4gJCSE0NBQevfuzZo1a7j33ntRFIW//vqLtm3bFjju+PHj1KtXjyuuuAKXy8WePXuYNGkSL7zwAocPH6ZJkybY7XZOnjxJbGwswcHB5OTkVHiaenEkGBfnxOFxkOpIJcudVSWC8LJSFMUbUJcSsOumjlN3kuPJKfIqpEWxoKkaAVoAVs3qe5w/Jb5QwK7rp0e5Xa7TQbfHg2ma3v3zUsvzUlzlxFycLdMEu73ARZtCu1Ryk0QRrFZvNotpomRmoqSlebdFRmIGB5da30EIIcpLjieHZHsyTo+TQEsggap/qkqL2umyyy5j8eLFXHrppQW222w2brzxRjweD7NnzwbgpptuYuHChdxwww0YhkGjRo147rnnChy3detW3nvvPSwWC0FBQTzyyCNERkby0EMPMXfuXNxuNwBTp04lNjaWK664gnvvvZe6dev6pYCb/LUXZ6W6BuFn42zmr+d4cjDc3rQh3+i6x4OqG1h0sHoMAt1g8XiwmSqKqqKioWkWVKvNm14uqeWiIsiFnOpBUU6Plns8qCdPgml6R8vr1IESLqoIIcQ/4dSdJNuTyXHnEKAFEGoL9XeTRC0xefJk3/34+HguueQS6tQpGFMMGTKEu+++u8C2gIAAHnjggRJfe9iwYQwbNqzQ9p49e7J06dJC28ePH8/48ePPovXlS4JxUSa1IQg/GyoKqg6KbqK4dRSnE9XpRHG5vfNrUdBNHV2BHA0MVcVQOR2w66Dq3nnqVtWKRbX4fqqovlF2SRETohaxWLzz6U0TJScHNTMTLJbTS6RZi87mEUKIs+E23KQ5vMXZbJpNgnDhNy+88AI///wzzz//vL+b4jcSjIsS1fog3DBQPLp3LrfHjepwobi8QXf+0SpT07y3M1LLtdxbkfLPX9edvkqa+eev543S5xWcs2qnq8Pn/ZTCKkLUMIoCgYHeXkDXUVNS4NQpzOBg7xJpMoVFCHEO8iqkpzpT0RSNUGuonEMIv7r33nuL3O6PdHF/kWBcFCkvCM/2ZNeOIFz3BtyKx7s2sOJ0eZcK0z2cLovpnc9tWjTMENs/f09FQVU0VDQsxcxfJ3f+ukt3YdftmK7CyeyaonkDds0brPtG1xUZXRei2tM07xxyOL1EmqadLvpmK4e+SAhRoxmmQZYri1P2U6BAiCVEgnAhqggJxkUBZwbhodYalLqUu3yTouveoDt3mTDV6ULxre+oYCoqaCpGvqXC/EZR0BQLGhQXrmPmX3/dk+0tBpd/dB0FZ0AIWmgIWrGvIoSo8vItkaampUFKCmZg4Okl0opZLk4IUTvlVUhPtifjMT1SIV2IKkiCcQHUsCA8N7Uc3btUmOJworpc3tRy8AbeCpiaBVPTMKp5gSRFUbGU8sfV6XEQiFF8yrwQovpQ1dOj5XlLpCmKd2553hJpQohaze6xc8p+CpfuIkALIECVfkGIqkiC8VquWgfheSPcuu49IXW6UJwOFLfn9D6KWux8biGEqPbylkgzDJSMDJTUVAgI8M4tDw4GTS7BCVGbOHUnKfYUst3ZBGgBhFhD/N0kIUQJJBivpapVEJ4/tTxvPrfTiaLr3kRs5XRqualZMG1y9VcIUcuo6ukl0txu1BMnAE4vkRYQIBcjhajB8iqkpzvTsWpWqZAuqq309HT+/e9/A5CSkoKqqkRERACwZMkSrKWsLLJ161asVitdunSp6KaWCwnGa5kqG4Tnn8/t9niXCssNvPOWCjMVE1PVvMWLbDaZHymEEEXJGy03TZTsbJT0dO+2yEjvaLlF/vQLUVOcWSE9xCrF2UT1Fh4ezttvvw3A0qVLCQoKYuLEiWU+ftu2bQQFBUkwLqqWKhOE55/P7T77pcKEEEKUUe4SaQB4PKgnT3qXVAwNxQwL846kS/8qRLWUVyE92Z6MqZhSIV3UaLt37+bll1/GbrcTHh7OQw89RN26dVm9ejXr1q1D0zSaN2/Obbfdxrp161BVlS+++IJ77rmH7t27+7v5JZJgvIbzexBumt6K5XYHWnomtpRkCi0VppXTUmFCCCGKZrFgWizePtnpPL1EWkQEZkgIlJL2J4SoGvJXSHebboK0IDRVakOImss0Tf7v//6Pp59+msjISL7++msWL17M7Nmzeeedd1izZg02m43MzEzq1KnDqFGjzno03Z8qNBj//vvvmT9/PoZhMH78eKZNm1bg+SNHjjB79mxSUlKIiIjgueeeo0GDBgB89NFHvPbaawDcdtttjB49uiKbWuP4NQg3DG8Anp2DlpUNuu5NL69XFyNYCokIIYTfKIq3wFtAAOg6akoKnDqFGRzsLfoWGChTgISooqRCuqhsq3av4r1d75Xra07sMJEJ7SeUeX+3283ff//N3XffDYBhGERHRwPQunVrHnvsMS666CL69+9fru2sLBUWjOu6zrx581i2bBkxMTGMGzeOgQMH0rp1a98+zzzzDKNGjWL06NFs3ryZBQsW8Nxzz5GWlsaiRYtYu3YtiqIwZswYBg4cSHh4eEU1t8bwWxCu695q5tnZaFnZKKaJcebcbqnqK4QQVYemnV4izeXyjpar6umibzbJWBJepQ2uvP/++7z33nuoqkpwcDCPP/44rVu35scff2TBggW43W6sViszZszgwgsv9NOnqL58FdI92QSoUiFd1C6madKiRQsWL15c6LnnnnuO33//nR9//JG3336b//znP35o4T9TYcF4fHw8zZo1o2nTpgAMHz6cjRs3FgjG9+/fz6xZswC44IILuOOOOwD44Ycf6Nu3r69yXt++fdm0aRMjRoyoqOZWe3lBeJYnC5tqq5wg3ONBdbpQM7NQ7TlggmmxYMg8RCGEqF5sNkybDQwDNT0dUlMxAwO9Rd+CgmS0vBYry+DKyJEjueaaawDYuHEjTz31FEuXLiUyMpLXXnuNmJgY/vrrLyZPnsymTZv89VGqnfwV0i2qpeoU3RW1xoT2E85qFLsi2Gw20tLS2L59O507d8bj8ZCYmEjz5s05ceIEPXv2pFu3bnz99dfY7XaCg4PJzs72a5vPRoUF40lJSb6Uc4CYmBji4+ML7NO+fXu+/PJLJk2axFdffUV2djapqalFHpuUlFRRTa3WzgzC61jrVOwbut2oDgdaZhaq04VJXgAeLAG4EEJUd6p6erTc7S44Wh4aerognKg1yjK4Ehp6Oki02+2+QmIdO3b0bW/Tpg1OpxOXy4VNsi5KpBs66c50UpwpUiFd1HqKovDEE0/w4osvkp2djcfjYcKECcTGxjJv3jyysrIwTZPx48dTp04d+vbty8MPP8ymTZukgFtpHnjgAR5//HE++ugjevXqRUxMDNo5pjJrmuabP1ASi8VSpv2qOofHQXJOMllmFiFhIURZoirmjUwTXC4UuwM1IxPF5fJurhMGUWdX8EezaETIVAO/cGWlEB0VjTUw2N9NEUJUF/mXSMvMRElL8843j4jwBuwy9ahWKMvgCsC7777LsmXLcLvdvmWJ8vviiy/o2LGjBOIlkArpQhQ0efJk3/1XX3210PN59cXyi42NrVbp6hUWjMfExHD8+HHf46SkJGJiYgrts2jRIgCys7P58ssvCQsLIyYmhl9//bXAsb179y7x/XRdJzk5udR2RUdHl2m/qsrhcZDi8M4bsqk2ArQAPHjIIaf83iSvAnqOHS0zCzweUFTv/G9L7smXx3PWLxsRHk5aenr5tVOUWYCpk5ySjDXAXuJ+DRs2rKQWCSGqDUXxLoMG3tHyEycAMOrU8c4tDwyUzCjBtddey7XXXsv69et57bXXeOaZZ3zP7d27l+eff5633nqr1NepbYMrcLpC+onsE7gD3MSExFTpCukWi4XIyEh/N6PWMUwDA4PoyJrx7154VVgw3qVLFxISEjh06BAxMTHExcWxYMGCAvvkVVFXVZXFixczduxYAPr168cLL7xAem7g9sMPP3DvvfdWVFOrhTOD8HJPRzcM73I3uRXQFcPAUDUMmxUCpFqnEEIICo6W5+SgZmaCxYIRGekdLbfIiqk1TVkGV/IbPnw4jz76qO/x8ePHmT59Os888wyxsbGlvl9tGVzJc2aFdItqIYMMfzerRJGRkaSmpvq7GbWOYRqEhIWU+u9eBlaqlwr7q2mxWJgzZw5TpkxB13XGjh1LmzZtWLhwIZ07d2bQoEH8+uuvvPDCCyiKQq9evZg7dy4AERER3H777YwbNw6AO+64w1fMrbap0CA8twK6mpWNmpWFAt4K6AEBUqxHCCFE8RQFAgMxwVvM8+RJAIyQEMywMO9IuoyW1whlGVxJSEigefPmAHz77bc0a9YMgIyMDKZNm8Z9991Hz549K7vpVVpehfQsT5ZUSBeiFqvQS9gDBgxgwIABBbbdddddvvuXX345l19+eZHHjhs3zheM10YVFoR7PKh2hzcAd9gBBVOzYARLATYhhBDnwGLBzB0RV5xOb9E3TcMID8cMCZEl0qq5sgyurFixgs2bN2OxWAgLC/OlqK9YsYLExEReeeUVXnnlFQDeeuutGpNefi7chpt0RzqpzlSsqrXiC+8KIao0xTRN09+NKA8ul6tGpDUVNSf8n1JcbhRnbgV0hxNTUTAtFu8yNpVI5oz7T4DpIrBJB6wBJRdwk9Smqq1M/ZzHQ3R6Oqlud+U0ShQg6Zu5dN1b8FPXMYODvUXfAgMrNOuqrH/fpZ+r2mrK+dyZdEMnw5VBiiMFVVEJ1AKrbXE26ef8Iy9NPdwouRjyP+3jduzYUeJUFHFukpKS6NSpU6HtMrmriijXkXDT9AbgDgdaZiaKyw2KgmGzoYdIGpQQ5en7779n/vz5GIbB+PHjmTZtWoHnn3zySX755RcAHA4HycnJbNmyBYCPPvrIVwn0tttuY/To0ZXbeFFuTNMkx5NDVkYWWVlZ2Czei6maomFRLWiKVm1PvM+JpnnXJwdwuQovkSa1SEQtkb9CuoFBkCUIVZGpgEIILwnG/azcgnDT9KYH5tjRsrILVEA3QyRFUIiKoOs68+bNY9myZcTExDBu3DgGDhxYYP3d2bNn++6/88477Ny5E4C0tDQWLVrE2rVrURSFMWPGMHDgQMJl+b9qx6W7SLYn4zJc1A2s6z35dmeR6coEvIG6oihYVIs348kSgFW1oima91aFqyaXC5vNm4llGCgZGSipqd4l0iIjvQG7LJEmaiDTNLF77JzMOYnbdBOkBdX833UhysH06dO5/vrr6dOnj2/bqlWrSExMZMaMGUXuf8cdd9ChQwfuu+8+Hn30UerUKRhPLV26lKCgICZOnFjs+37//fc0bdqUFi1aAPDmm2/SvXt3zj///HL6ZEWTYNxPyiUIz6uAnpXtrYBumlIBXYhKFB8fT7NmzWjatCngrSK8cePGAsF4fnFxcdx5552Ad5WIvn37+opT9u3bl02bNjFixIhKabv453RDJ92ZToYrA4tqIcgSjFW1YtGsWLAW2t8wdFy6C7tuJ/8MMUVRsCpWArQArJoVi2rBoljQVK1mjaCpasEl0o4fLzhaHhjo3/YJUU7yV0i3aTZC1VB/N0mIamPw4MF8/fXXBYLxr7/+mjvuuKPUY88sLnk2vv/+e/r27esLxqdOnXrOr3U2JBivZP84CNd1VIc3AFdzvGuLm5qGUcFz8YQQhSUlJdGgQQPf45iYGOLj44vc98iRIxw+fJgLLrig2GOTkpIqtsGiXOStCZziSAEFgi1lK4CpqhoqWuEw3TTxmB6yPdkYbgNMMBVvsG5RLNg0GzbVhs1iQ8M7kl7t097zL5GWmYmSluYdQY+IkCXSRLWVlyUjFdKFOHeXXHIJixcvxu12Y7VaOXbsGMnJyXz11Ve89NJLOJ1OLrnkEqZMmVLo2LFjx7J06VIiIiJ4++23+eyzz4iMjKR+/fq0a9cOgE8++YSPP/4Yj8dD48aNmTNnDnv37uWHH37g999/Z/ny5cyfP5/ly5fTt29fLrnkErZs2cKiRYvQdZ0OHTpw//33Y7PZGDt2LEOHDuXHH3/E4/HwxBNP+FaTKCv5a1dJ/lEQ7nb7AnDNbscETIsVQ5aOEaLaiIuLY8iQIWj/ICVX07TSqxB7PFiys4kMlZGYiuDUnZzMPolLcVEvuB6aUvD/p2bRiCjHqQa6qeMxPRiGgcN0oODt8xUUb5Cu2Qi0BGLRasBouscDDgekp0NYGISHe0fLy/h3zmKx1Ooq3cJ/PIaHNEeaVEgXohyEhYXRsWNHfv75Z/r378/XX3/NwIEDueGGGwgLC0PXde666y727dtXbCbi7t27+frrr1m+fDm6rnPTTTf5gvEBAwZwxRVXALB48WLWr1/P+PHj6devny/4zs/pdDJ//nwWLlxIbGwsjz/+OB999BETJkwAIDw8nGXLlvHhhx/y3nvvMWvWrLP6vBKMV7BzDcJ9FdDTM1FdLkwFTKsUYBOiKomJieH48eO+x0lJScVWIP3000+ZM2dOgWN//fXXAsf27t27xPfTdb1s1dQ9Hql0W848hseXkm5TbVg1G5lkFdqv0laNME3sph3d1DFMA5PTae+aomFVrb5gvdoVkTNNOHIEJTERLJbTS6RZC6f+5yfV1EVlO7NCeqg1tHr8jglRRgGrVhH43nvl+pqOiRNx5gayxbn00kv5+uuvfcH4rFmz2LhxI5988onvXCghIaHYYPyPP/7goosuIjB3+lO/fv18z/39998sXryYrKws7HZ7qedeiYmJNGzYkNjYWACGDh3K2rVrfcH4xRdfDEC7du347rvvyvQd5CfBeAU56yDcNFFcLu8a4JmZKG6PVEAXoorr0qULCQkJHDp0iJiYGOLi4oqcr7R//34yMjLo0aOHb1u/fv144YUXSM8N3H744QfuvffeSmu7KBvTNMlyZ5HqSAUFQiwhVSMjSVHQFAtaEX/GTdNAN3QyjUxMl5m7rRoVkVMUCAz0Xl7QddSUFDh1CjM4GCMiwjvvvCr8PxC1lmmaZLmyOGU/JRXShagA/fv356WXXmLPnj04nU7CwsJ4//33WbJkCWFhYTzxxBM4nc5zeu358+fz1FNP0aZNG+Li4ti2bds/aqs190Kxqqroun7Wx0swXs7OKgg3DG8AnmNHy8wCXfdWQA+wYdqkAJsQVZ3FYmHOnDlMmTIFXdcZO3Ysbdq0YeHChXTu3JlBgwYB3lHxYcOGFRgxiYiI4Pbbb2fcuHEA3HHHHb5ibqJqyOvP3bqbAC0AtSoFrCVQFBWLphZZRE43PDh1J3aPvcBouqIo2BRb1VuSTdO8c8gBXC60Y8dA006PlttktRBReXwV0u0n8RgeArXAqnUhS4hy5pwwodRR7IoQHBzMeeedx5NPPsmll15KdnY2QUFBhIaGkpKSws8//1xggONM3bt3Z/78+dxwww14PB5+/PFHrrzySgBycnKoW7cuHo+HL7/8knr16vneMye3Hld+sbGxHD9+nMOHD9OkSRM+//zzEt/7bEkwXk7KHIQbBqrDiZKdVwEdDM27BJkUYBOi+hkwYAADBgwosO2uu+4q8DivgvqZxo0b5wvGRdXhMTykOdPIdGcSoAQQZA32d5PKjaYWPZruKyLnzibTlYmC4gvWNUXDpgUQoNmwalZfETmLWsmnEPmWSFNTUyE5GTMw8PQSaUJUILvHTrI9GYfuIECT4mxCVLTBgwcza9Ys5s2bR7NmzWjTpg0TJ06kfv36dOnSpcRj27Vrx6BBg5g0aRKRkZF06NDB99zUqVOZOnUqERERdOzY0ReAX3rppTzzzDOsXr2aJ554wrd/QEAAs2fP5uGHH/YVcBs1alS5fU7FzL++SjXmcrnKNFesrHPKysrusZPiSCHHk+NN/dOKGNH2eFCdrtwK6NneSrkWi/ekohal2lXaXEpRSIDpIrBJB6wBJQcVMpeyaitTP+fxEJ2eTqrbXTmNqkHy1gdPdaSiKAqB2tkHeDWxnzMMHd3U0dF9S7KZmKioWFQLAVoANs3mnyXZ3G4UlwsUhYiWLSnLX3fp56o2f53PFdse3UWKI8V7cU71/luv7SIjI6UuiR8YpkFIWAjhRslFQv9pH7djx45i69+Ic5eUlESnTp0KbZeR8XN0ZhBeaCQ8twK6lpmJ6nBiKgqmxYIRVLYlcIQQQlSevFEvj+khSAtCkfmfPqUtyZbjySHLnQUm5BZ7zx1Nr4Ql2fKWSDMMSE6GyEjJMhPlQiqkCyEqgwTjZykvCLd77IWCcMXpQnE40DKzcq/USwV0IYSoyjyGh1RnKlnuLAKUAIIt0l+XmaJgUaxFzk03TQOP7sGhOzBdpi/tXSG3iJzmzSTLm5f+j4vISQAuyolUSBdCVCYJxsvozCA81BrqrYDudJ4uwObJq4Ae4C0sI4QQokrKS0nPO+EOsci67OWp2CJypolu6jg8DnLcOdWjiJyoFaRCehnoujcLxelEcXqnh5h5v5qKcjrzM/9P+d0VokQSjJeiUBCuBXsroKcmo2Vlg2lgKhqGzQoBUgFdCCGquryUdN3UJSW9spVhSbYsdxaZrszcbdVoSTZRLRWokK57CLTUwgrphgG6jmKYYOgoeu5jlwvF40HRdRS3B8U0MRUFS0YW1ox0fPNScimm6Q3QMTl9nS13H1XxZbCY6ukg3VRVyOuDVfV0cK+q+fZXvcfD6X3zBfqmwhkXAk7fL/ZiwZkXDkQBeX2vKB8llWir0GD8+++/Z/78+RiGwfjx45k2bVqB548ePcqDDz5IZmYmuq5z//33M2DAAFwuF3PnzmX79u0oisJDDz1Enz59KrKphRQIwk2NMI+Gkp3hTUEHDE3DCAiQ1DghhKgm3LqbVEeqt9aHZsNWVMFN4TclLclmGDou3YVdtxc4qVEUBatiJUALwGqEApGV2GJR3Tk8Dk7ZT52ukG6rYVmNplk4yDZ0FJfbG1x7vDdMI1/NBwUwMRUtNyBWMFUNM8h6OvgNCcHweM6uHWf+zPs1NkwU0+Pbrvh+vc18++cG+nkPfAcr3n1y2+XdR8FUcl8/L5jM3UfxvcIZFwvyAv28iwF5wbqiYCpK4YsFec8Xd7FAKeViACVdSMDvFwsCAwPJzs4mJCREAvJyYJom2dnZBAYGFvl8hQXjuq4zb948li1bRkxMDOPGjWPgwIG0bt3at89rr73G0KFDmThxIvv27WPatGl88803rF69GoD169eTnJzM1KlTWbNmDWolBL6+INyRSaAbIrKdqA57bgV0K0awFGATQojqxDANMl2ZpDnTUBWVYFmSqNoprYhctiebk7qdULMRKnKRXJTszArpodZqNk3FNMEwvMG1mftT96B4ckew3S7vttzpk/kOBFRMTc0NLFXMwMCKP68tJbAsy7JOFbr0U4GLBKcvAOQ9VkyPb7v3YkHhiwrFXizIJ+9Cg6mYBZ/Ld7HAN3WniIsFhgJa/SioW3I19X8qNjaWxMRETpw4UaHvU5sEBgYSGxtb5HMVFozHx8fTrFkzmjZtCsDw4cPZuHFjgWBcURSysrIAyMzMpH79+gDs27fPNxIeHR1NnTp12L59O127dq2o5mL32EnNSMKZnUZgtototyEV0IUQopqze+zeOaCmQZAWJH15TZO/iJzp8ndrRBWXVyE9zZWGRbFUzQrpvpRxwxdwK2435I5iq26P93lyU4k5Pfpq5qZ2m6qGadVk+mRZVZOLBabHg5Jjr8h3AsBqtdKqVasKfx/hVWHBeFJSEg0aNPA9jomJIT4+vsA+06dPZ/LkyaxYsQK73c6yZcsAaN++Pd988w0jRozg2LFj7Nixg2PHjpV/MG6a2HPSSU87hjv1FDYPhFusGLYA9BCZTi+EENWVW3d7s5x0OwFqAJomfboQtZVhGmS4Mki2J+cWbPRD+m1eynj+0WyPB8Xt9o5oe7w/MQ1A8c3PBjCV3CBbUzEsFgmya5u8f6uqXEyuifx6dhIXF8fo0aO5+eab2bZtGw888AAbNmxg7Nix7N+/n7Fjx9KoUSN69OiBppVcTEPTNKKjo0t9T4umER0Sgj31FOknEvE4swizWLDVawwWOVmrSJpFIyK8YlNrRNFcWSlER0VjDQz2d1OEqFB5yxKlu9LRFE2WKhOiFsurkJ7syC3YWBEV0vOnjBu587N1j3detm54U8bdHu+It+JNRC44L1s5PZodaJXsHSFqmQqLPmNiYjh+/LjvcVJSEjExMQX2WbNmDUuWLAGgR48eOJ1OUlNTiY6OZvbs2b79rr76apo3b17i++m6TnJycsmNMk1C01NIOLQHh+FCCwjGagsCHXKys8/uA4qzFhEeTlp6ur+bUSsFmDrJKclYA0pOb2rYsGEltUiI8mWaJjmeHFIcKRimQbAm04uEqK2KqpAeqBZdPKlEuUt5Kb5g25syrrg9oOemjHs8KIriDbF9o9mKd162klv8rDLmZQshqqUKC8a7dOlCQkIChw4dIiYmhri4OBYsWFBgn4YNG7J582bGjBnD/v37cTqdREVFYbd7q6UGBwfz448/omlagbnm58o0TY4nH8QdGECgVgXnCQkhhDhrecWYHLpDUtKFqOXKVCE933zswkt56Si6xxtw545ie4tz5y7blbsUl6mpGFZZ1lYI8c9U2BmLxWJhzpw5TJkyBV3XGTt2LG3atGHhwoV07tyZQYMGMXPmTB5++GGWL1+Ooig8/fTTKIpCcnIykydPRlVVYmJiePbZZ8utXSYmVs1Wbq8nhBDCP3RDJ92ZTrorHatqlZR0IWoxl+4i1ZFCpj2NAKzUUSwoLjcYjsJLeRWbMl70Ul5CCFFRFLOkVcirEZfLVWqaumkYZB3YhlORYNwfJE3dfwJMF4FNOmANKHnOuKSpV21l6efweIhOTyfV7a6cRvmBaZpku7NJcaSAgjf9tIqcNEs/5z8200Vo826opWRG1NZ+LjMzk02bNpGUlAR4pxP269ePsLAwP7esoDL1c4ZBdEAAKUlJ6E47GVnJZNpTsZgQqAb4Cp95l4xSC6SMo6lVpr+orqSf8w9T9xAcYCEktkuJ+9XWPq66ksU4hRBCVBtOj5Nj2cc4ZT+FTbURKMuVCVGqdevWMXr0aH755Rfsdjt2u52ff/6ZMWPGsG7dOn837+y5XBhHDpN16jBHkw+Q7ckiKCgca50o9JAQjOBg7y0kBCM4CDMgANNmA4sm/YUQokqRiXVCCCGqPI/hIcPprZJuU20EWyUlXYiyeu211/jwww8LjYKnp6dz1VVXMWrUKP807Bx5DA9Hso6RiouAoDoo5V0hXQghKokE40IIIaqsM1PSQywhMrIlxDkoal1tVVWpjrMVdUNHNz0EWoL83RQhhPhHJBgXQghRJTk8DlIcKbh1NwFaAKqq+btJQlRLt956K6NHj6Zv376++aRHjx7lp59+4vbbb/dz64QQovaSYFwIIUSV4jE8pDvTyXBlYFNtBFlLLjxYJXg8BO4/gDUiAupFe6syC1FFjB49moEDB/LDDz/4Crj16dOH++67j/DwcD+3Tgghai8JxoUQAti6dStHjhxB13Xftuo2j7K6M02TLHcWqY7UKp+SrqWmEbx9J8HbdxG8YxfBu/5CdToBqBcaQk6nDmR37UROl07kdGyHGRjo5xaL2i48PJw+ffoUqKYugbgQQviXBONCiFpvxowZHDp0iPbt26Np3lRoRVEkGK9EDo+DZEcybsNNkBZUtQoyeXQC/z5wOvDevpOAI8cAMCwWHG1akXLFUD6LbEcgMPD4n4T8uYMGb74NgKlp2Nu2JqdrJ7K7dCSnSyc80VF+/ECittm1axdz584lMzOTBg0aYJomx48fJywsjLlz59KpUyd/N1EIIWolCcaFELXe9u3b+fTTT4sscCQqlsfwkOpMJcudRYASQLDF/1XStbT03KDbG3wH7dqDZncA4I6OIqdTB1KuHE5O547Y27XGDAgAYNVPHiyaRvsbBnpfJyPD+xp/7iAkfgdRH22g7qoPAXA2bkhOl05kd+lETtdOOJs1ldR2UWFmzpzJvHnz6NatW4Htv//+O7NmzeKTTz7xU8uEEKJ2k2BcCFHrtWnThpMnT1K/fn1/N6XWMEzDl5KuKAohllD/NETXCTxw8PSo9587CTh8BABTU7G3bkXqsMvI6dyRnM4dcDeIKXPqvB4WRua/+pD5rz4AKG43gXv2ERK/neA/d1Ln59+I/PxrADx1QsnJHTXP7toJe/u2viBfiH/KbrcXCsQBunfvjt1u90OLhBBCgATjQghBamoqw4cPp2vXrlitVt/2119/3Y+tqrnsHjvJ9mR0UydQC6zUlHQ1I5PgHbsJ3pE733vnHrScHAA8EeHkdO5Ayogh3lHv9m3Kda63abVi79wBe+cOuRtMbIeOEPLnDoL/3Elw/HbCfvoVyE1/b9fGN+88u0tH9MiIcmuLqF0uuugipk2bxqhRo2jQoAEAx48fZ926dfTv39/PrRPVicfQcehOTNOUbDIhyoEE40KIWu/OO+/0dxNqBY/hIcWRSo47G5tmw6ZV8MivYRCQkFgg5TwwIREAU1VxtGpB2pBB5HTuQE7nDrgaNazcgnGKgiu2Ca7YJqQOHwLkpshv30lI/A6C/9xB9JqPqff+GgCcTZt455x37UROl444Y5tW2QJ3omp5+OGH+e6779i4cSMnTpwAoH79+lx77bUMGDDAz60T1UGGO5N3D33Mu4kfkeHJQkUlSAvMvQXku3/GTS1muxZIYL7jgtWC29WqVDdEiAokwbgQotbr3bs3p06d4s8//wSga9euREdHl+nY77//nvnz52MYBuPHj2fatGmF9vn0009ZtGgRiqLQvn17FixYAMCzzz7Ld999h2EY9O3bl4ceeqhGjjQYpkGmK5NUZyqqohJsrZh54WpWNsE7d3sD7+07Cd65Gy0rGwBPWB1yOncg7bKB5HTugL19O4zgoHJ9/7qBYLVqgHHOr6FHhJPZ70Iy+10IgOJ0EbRnL8Hx2wn5cydhP/5M1KdfAqdH8vPmndvbtcG02crjo4gaaMCAARJ4i7OW6krnncQPWXnoE7L0HC6uewG9Y7qTkp2GXXfgMJzYdUeBW4orLff+6eeMs+wXA9WAkoP9EoL8YoP/3Ne0qhL+iKpD/jUKIWq9Tz/9lOeee47evXtjmiaPP/44DzzwAJdffnmJx+m6zrx581i2bBkxMTGMGzeOgQMH0rp1a98+CQkJLF68mPfff5/w8HCSk5MB71JqW7du9RVOmjhxIr/++it9+vSpuA/qB/lT0su1SrphEHDocG7gnVvhPCERxTQxFQVHy+akDRrgnevdqQOupo0rfBT5vvMsRITXIS09vdxe0wyweUfCu3biFIBpEpB4iODckfOQ+J2E/fAzAIbNir1d29NLqnXpiB4eVm5tETXTI488wuOPP+7vZogq5pQzhbcT1/LB4Q04dCeD6/djaotraFenFRHh4WfVz5mmictwewNzw1EoeM9/yznj8ZnB/klnyhnHOHGb7rP6bBbFUkSwHlBikB9cWrCfe5xNtdbIi+qi4kgwLoSo9V5//XXWrFnjGw1PSUnhxhtvLDUYj4+Pp1mzZjRt2hSA4cOHs3HjxgLB+AcffMC1117rW8837z0URcHlcuF2uzFNE7fbTd26dSvi4/mFW3eT6kglx5NTLinpak4OQTv3ELx9FyHbdxK0YxeWzCwA9NBQcjq1J33QALI7dcDesR1GiP+rslcIRcHZLBZns1hSRw4FwJKS6p1znlu1ve6qD1Hf/QAAR7OmuUuqeQN0V5NGktpeC6WlpRW53TRNvvvuu1KPLy0D6P333+e9995DVVWCg4N5/PHHff3gG2+8wZo1a1BVlYcffljmqFdxSY5TLDu4mrVHPsVteBja4GKmNL+aVqHNzvk1FUUhQLMRoNmIoPwvEHoMvdQgv6hbXqCfdwEgw51Fkn6q0D5no6j0/cC8++cwmp8/fT8Ardy/O+F/EowLIWo90zQLpKVHRERgmmapxyUlJfmKIQHExMQQHx9fYJ+EhAQArr76agzDYPr06Vx00UX06NGDPn360K9fP0zT5LrrrqNVq1bl84H8yDANMpwZpLnS0BTt3FLSTRPb4aPeVPPcCueBBw6iGN40R0fzWDIu7kdOJ2+Fc2dskyqxLNib23UCArK4oU3lvq8nKpKMAX3JGNAXAMXpJGjXX97CcPE7CP/vD0St/xwAd2SEb9Q8u0snHO1aY+YrWihqpgsvvJBGjRoV6NcURcE0TVJSUko8tiwZQCNHjuSaa64BYOPGjTz11FMsXbqUffv2ERcXR1xcHElJSdx000188cUXaJoEFVXNUXsSSxNWse7ol5gYjGgwiMktrqZZcGN/N61UFlWjjhpCnQpYGtMwDRyG65wD/fy3NFdGwW2GA908u/T9GW0nc09sl3L/nMJ/JBgXQtR6/fr1Y/LkyQwfPhzwpq1fdNFF5fLauq5z8OBB3nnnHY4fP851113H+vXrSU1NZf/+/b5RqZtvvpktW7bQq1evYl9L07TS57J7PFiys4kMrdylwkzTJNudTbI9GTPIpGGdhiiUbQRWybFj27ET2x/bCfjjT2x/bEdLTQPACA3B1aUTGZcNxNWtC84unTDD6viODcq9VQWJ2WkoOToRuVkQflW/Pu4B/UgH0g0Dy98JBGz9g4Df4wnZFk/49z8CYAQE4OrcEVePrjh7dMPZrTNmNU1td2WmEB0djarJqc2ZmjZtyvLly2nUqFGh50qbR16WDKDQfP2N3W73pelu3LiR4cOHY7PZaNq0Kc2aNSM+Pp4ePXqUx8cS5SAx5whLE1ax/tjXKKiMajSYm5tPoHFQg9IPrgVURSU4N029vJmmidt0F0q7PzNV3xfge+z0r9uz3Nsh/KtC/2KVltZ09OhRHnzwQTIzM9F1nfvvv58BAwbgdrt5+OGH2blzJx6Ph1GjRnHLLbdUZFOFELXYgw8+yBdffMHWrVsBmDBhAoMHDy71uJiYGI4fP+57nJSURExMTKF9unXrhtVqpWnTpjRv3pyEhAR+/fVXunXrRkhuOnX//v3Ztm1bicG4ruu+OefF8niI9nhITU0ttf3lxaW7SHGk4NAdBKgBaKqFdDKK3tk0sR49TsiO3CJr23cRuP9vFD131Du2CekXnp+7rndHnM2aQv5RNNOAcpyTXZ48uo5F08p1zni5qRcNQwZ6b4DlVDLBf+70jZ7XWfYOYUveBsDRolm+JdU64W7UoFqktttM7+9HacF4w4YNK6lFVcekSZPIyMgoMhifMmVKiceWJQMI4N1332XZsmW43W7efvtt37H51zePiYkhKSnpXD+GKEd/Zyfy5oH3+ez4t1hVC1c1GcmNzcbRILCev5tWayiKgk2xYVNthFtLvwhq6h6CA+RiY01TYf9Hy5LW9NprrzF06FAmTpzIvn37mDZtGt988w2ff/45LpeL9evXY7fbGT58OMOHD6dJkyYV1VwhRC03ZMgQhgwZclbHdOnShYSEBA4dOkRMTAxxcXG+Sul5Lr30UuLi4hg7diwpKSkkJCTQtGlTDh8+zAcffIDH48E0TX777TcmTZpUnh+pwumGToYrgzRnGlbVSnARKYKK00nQ7r9OVzjfvgtr7qi3HhSEvWM7Tl53tXd5sU7t0cOq56hsdeOpG03GJf3JuMQ7f1exOwjetZvg+J2ExG8n4utvif74UwDc0VHewLxrR3K6dMLephVY5ISwOrn22muLfe76668vt/e49tprWb9+Pa+99hrPPPPMOb1OWTKAHAEaJ05qRIRVgSyUamZX+l5e2rWcT498Q6AWwNQ21zC17UTqB5ZtBREAzaJVjQygWsYwPJhOZ5lXexHVQ4X9NS1LWpOiKGRleQvwZGZmUr9+fd92u92Ox+PB4XBgtVoLpEAJIUR5uOaaa3j//ffp0aNHgeqnpmmiKIpvpLw4FouFOXPmMGXKFHRdZ+zYsbRp04aFCxfSuXNnBg0aRP/+/fnxxx8ZNmwYmqbxwAMPEBkZyZAhQ/j5558ZOXIkiqLQv39/Bg4cWNEfuVyYpkmOJ4dkezIoEGIJ8Y6cmibWpBMFAu+gvftRdB0AZ5NGZPXuSU4Xb4VzR8vmBUe9hd+YQYFkn9ed7PO6cxJA1wk8cJDg+B3e0fM/dxL+7SYAjMAAcjq2zw3QO5HTqQNGaA0tmFfDuFwuvv/+exITE4mKiuKSSy7xFZcsTlkygPIbPnw4jz766DkdC2XLAHJmpWMYetXMQqmidmbs5Y0D7/Lfk5sJ0YKZ3HwC18eOIdIWDk5Ic5b9uzzbauqifOSNjJf2+1Ebs3+qswoLxsuS1jR9+nQmT57MihUrsNvtLFu2DPCOUG3cuJF+/frhcDiYNWsWERERFdVUIUQt9f777wOwbdu2c36Notbuveuuu3z3FUVh1qxZzJo1q8A+mqYxb968c35ff3HpLpLtybgMF4FuhZB9fxcc9U72FoMyAgPIad+OkxPHeQutdWqPHhnh38ZXsMYhYLP9s3XGqwxNw9G6JY7WLUkZMxIAy4mTvsA8JH4H9d5ZSX3D8C0l5wvOu3bCHVO/WqS21yZfffUVb731FkOHDqV169akpKRw1113MWPGDDp16lTscWXJAEpISKB58+YAfPvttzRr5q28PXDgQO677z5uuukmkpKSSEhIoGvXrhX2GUVhf6Tt5I0D7/FD8m/UsYRyW8vrubbplYRZ65R+sBCiwvk1zywuLo7Ro0dz8803s23bNh544AE2bNhAfHw8qqqyadMmMjIymDhxIv/61798o+xFKUtak2kY2A9ZiAiV1Bp/kLQm/3FlpRAdFY01MNjfTamSEhMTadCgATabjV9++YU9e/YwatQowiRl2kc3dLIP7YPf/0fDnX9RZ8dfBO7dj+r2ru/qatiArJ7dyenUgZzOHXC0agmW2jXqPb1b+a8zXpV46tcjfdDFpA+6GMhdbm7HbkL+3Elw/HYivthI9LoNALjr1c0377xjrfz3UJVs3bqVlStXsnz5cl89nsaNG3Pdddfx4osvcvnll9O8eXN69ixcHKosGUArVqxg8+bNWCwWwsLCfCnqbdq0YejQob7MoDlz5kgl9UqyJTWe1/9+l19TfyfSGs6/W93E1U1HEloBFceFEOeuwoLxsqQmrVmzhiVLlgDQo0cPnE4nqampbNiwgf79+2O1WomOjua8887jzz//LDEYL0tak2kY6B5PjT1Rquokrcl/Akyd5JRkrAH2EverralNd955J2vXruXgwYPMmTPHN5rz5ptv+rtp/uN2Y9m9G2t8POrvW7HFx9PopLePNWw27O3bkDx+lLfQWqf2eKKj/NxgUdmM4GCyzz+P7PPP827w6AT+fYCQ+B2+Nc8jNnpXC9CDgsjpdDq13d6pPUawXBysLEuWLGHu3LkEBAQQFxfHn3/+yfnnn89vv/1Gjx49+Ne//sW8efOKDMah9Ayghx9+uNj3vu2227jtttvK54OIEpmmyeaUrSw+8B5b07YTbYvkvjZTGd9kRIVUAxdC/HMVFoyXJa2pYcOGbN68mTFjxrB//36cTidRUVE0bNiQX375hVGjRpGTk8Mff/xR7QobCVEVGKaBQ3eiSbZoiVRVxWKx8NVXX3Hddddx/fXXM2rUKH83q1KpJ09ijY8/fdu1C8XlAsAZU4/sLp041aWTd9S7dUtZm7oIi/7wYLNlMq2Dv1viJxYNR9vWONq2JnncladrCMTv8I2e11/+LoppYqoqjtYtye7SkZyu3qrtnvpSxbmiHDt2jNjYWAD27NnDO++8g81mw+l0MnXqVBo2bMjhw4f93EpxrkzT5PtTv7D4wPv8mbGbmIC6zGp3O6MbXU6gFuDv5gkhSlBhwXhZ0ppmzpzJww8/zPLly1EUhaeffhpFUbj22muZNWsWw4cPxzRNxowZQ/v27SuqqUL4jW+NSY8du8eOw2PH4XbkPnbg9Nhxehw4dO9Pp9uJQ3fg8ji8jz0OXB4XTt2BU3fi0p24PU5cntz7uhvFhPpN2/Of2A3+/rhVlsViYcOGDaxbt47XXnsNAI/H4+dWVSC3G8vevVj/+ANbbvCtHTsGgGm14urQnpSxV5DcrjnOLp0hpnZmTJytI9lgcehQxvXVazxFwd0ghvQGMaRf5i1OqGZlE7xjl2/0PCruC+qu/QQAV0x9X2Ce06WjFPgrRxaLhaysLEJDQzEMg7///pv27dtz4MABPB4PLpeLwEAZOa1uDNPgm5M/sfjA++zO3EejwBjmtL+LKxpdik21+bt5QogyUEzTNP3diPLgcrnKlKaedWAbTkU6qIqm5uRgOZWCNTkFS3IKlpQUQjwGDrsdTAPFML3rBRsmimmCaYJheO8bJmCiGN7nT++fdzv92LcPZxx/xjGKYRR8j9z9FLPo98i/P6aBaeTddEzTAN/90/vga+/p11PM3Jvh/TVTDBPVNFFMUHNviglqBf//2N2oMcE/foc1oOS00Nqapr5v3z5WrlxJ9+7dGTFiBIcOHeKzzz5j2rRp/m5aAWXp5/B4iE5PJzV3LjeAmpxceNTb4QBAr18fd7duuLt0wdW1K6ktG5NqZIMCgWqgFOE6C7N+8mDRNB7vI99ZmXk8BO37m+D47YTE7yT4zx2+IoB6SLC3BkFegN6xPWZQ8QGjzXQR2rybrDNehLfeegu3280tt9zCwYMHWbBgAWlpaURERHDPPffwyy+/kJqaWiXSycvSzzmz0nEl7cWp1M5RX93U+TJpE28eeJ992Qk0C27MlOZXM6zBQKxqxZeDkmmH/pFXTT0ktkuJ+9XGPq46k2BclJ1hoKVneAPslFQsySlYT+UG28nJBbZrdkexL2MqCqgKoGCqqvdkX1UwFdW7XVFy9/E+59tHUTBVBXL38+2PgqGCoeTeyPtpoismhgK64r2vk3tTTDwYp39i4MHEoxi4MfD4bjoezNOvnXszz3js2w6YKqiqBVXVvD81DU2xoGkWVDX3p2ZBUy1YVCuadvqnplmxaFYsqvenVbN5H2s2rLnPqarm++z5v7MC35WqYgKoKu/tNUmMiWXmnZdJMF7NlSkYdziou2UL9v/9zxt4//knltz0U9NiwdO+Pa6uXXHn3ozcVS8cHgcpjhTcupsALQBVlRHJsyXBeDkwTaxHj+dWbffOOw88cND7lKZib9OanC4dye7amZwuHfHUPV24VYLx4rlcLqZNm8bQoUOZMGFCgefWrl3LunXrWLp0KTab/8+PJBgvnsfQiTv+DUsSVnIw5zCtQmKZ0uIaLo8ZgKZUXp8twbh/SDBeMxX7FyslJYWUlJQC64KDdwQpKiqKqCgp1lNjeDxYUlJ9o9inA+wUrCn57ien+tYLzk8PDsYTHYU7Ogp7u7Z46nrve6IivT9znzPr1eF4+inshhOH4cSuO4q8OXQndqPgtpy87XnbDAd23e7b3+TsrikFqgEEaYG5t/z3c2+q92dgUc/l3gq+RiDBuT+tavnOpfXk3oq/vFGyH4I9qGYNWGqpAtx1110sXLiQkSNHFvn8+vXrK7lF/1zkTTdh/e47rIBety7url2xjxvnDb7bt4czUlE9hoc0ZxqZ7kwClACCrFJUS/iRouBu3JC0xg1Ju/xSANSMTEJ27CI4fjvBf+4k6uNPqbt6HeCt4p9Xtd3evxc091/TqzKbzcbixYtZvHgx48ePp2HDhmiaxrFjx+jTpw9vvvlmlQjERdHchpuPj33F0oRVHLEfp11oS57v8jCX1u+LqlR0bp0QoiIVOzJ+zz33MHHiRM4///wC27ds2cL7779fqBibv8nIeGGK3YE1OblggJ0v6PYG2ClY0oq+uumJCD8dTNeNwhN1OrD2REd5g+6oqBLTBtNcGaw79gWrD8dxyH6szG23KJYiAuAAX5BcVBAdqBYfXAcW2M9Wq/54vbldR0PnniEdZGT8DCdOnKB+/focOXKkyOcbN25cyS0qWVn6Odt33xGemEhqp04YDRsWm2ZumAbZ7mxSHCkoikKgFlQRTa5V3tyuExBg44Y2hS9aivKjuN0E/rWfkNzgPPjPHVhT08i86EIy3l0lI+NlkJLinQpQFQdWZGT8NKfu4qOjn/NWwgccd56kc1hbprW4lgF1+6D4cQqRjIz7h4yM10zF/sU6ePBgoUAcoFevXjz66KMV2SZREtNEy8jMDaSTsSSnng6q849sp6Si5eQUOtywWPBERXqD6oYx5HTugCc6+owAOxJPVCRYzn3e0Z/pu1l1eAOfJ32Ly3BzXkRnbmg9Ds2tlmnEuTLmPNUWUztrBJgSHBSlfv36ABiGQf369QkI8J7YORwOTp065c+mnTNX374YnTtj5Jszfia7x+5NSTfcBGlBKLXo4lRFGtryBJmWbPZlWYi0RRBhrVOpqaO1hWm1Yu/UHnun9nANYJrYjhxFDQtC8jpKt3XrVo4cOYKeL9Ottq0eUdXZdQdrDn/K8oOrOelKoUd4J+Z2vJt/RfX0axAuhCh/xUY82dnZxR7kLuEkT5wjj44lNRVLcurp0ezkginieSPbahHfvx4UhCfaG2Tb27YqOIKd774eVsc7F7sC2HUHXyR9x6rDG9iR8RfBWhCjGg3hqiYjaBvaQq6kiirrrrvuYuXKlb7Hqqpy1113sXbtWj+2qvx5DA+pzlSy3FkEKAEEW0L83aQaIcOdxWt/v8PKw5+g55sSoqAQYQ0j0hZOpDWcSFs4UbYIIq3hROVui7JFEGmLIMoaTrg1DIvM1T97ioKrSWNspsvfLanyZsyYwaFDh2jfvj1abqV6RVEkGK8isj05rDq8nrcPriXVnc75kd14qvODnB/ZTYJwIWqoYoPxZs2a8d133zFgwIAC27/77juaNm1a4Q2rKRSns0BVcWtusTNv0H062LakpXurfJ/BEx7mC6adsU1yg+rcke3oaF+wbQT7L8X0YM4RVh/ewLqjX5LhyaJVSDNmt5vOiIYDCZWTfb9bsNWDCjzaxN8tqbp0XS8wX9Jms9Woi46GaZDlziLFkYKqqIRYQv3dpBrBMA0+PvoVC/e/RaornTYBl9Mq6GIuaZJGqjudFFcaKa50Ut3ppLrS2Z91kC3ueNLdmUXWuVBQCLfW8QXuecG6N3CP8G7LDeijrOFEWMMleBdnZfv27Xz66acS2FUxGe4s3j/0MSsOfUS6O5N/RffklhbX0iOik7+bJoSoYMUG47Nnz+aWW27hs88+o1Mnb2ewfft2fv/9d15//fVKa2CVZJqomVlnBNhF39eyC6eKm5qKJ8obYLtj6mPv0M47J/uM0WxPVCSmtXyLgZUXj6Gz6dQvrDq8gZ9S/odF0bi0fj+uajKSnhGd5Q99FXLK4V1CTRQvKiqKjRs3MmjQIAC+/vprIiMj/dyq8mH32Em2J6ObuqSkl6M/03fz1J5X2Z6xh+7hHXm1+xO8s70FFl3j8gYl938eQyfdk0mKK41UV5ovWE/Odz/Vlc6BnENsTdtOmjuj2CKVYZbQ3NH1cKJyA/a80XfvtnDf8xHWcJkCVMu1adOGkydP+qboCP9Kc2Ww4tBHvJe4jiw9hwF1L2Bai2voEt7e300TQlSSYv8qN2/enPXr17N+/Xr27t0LwPnnn8+8efN88yprHF3HkpqWW0U8Ny38zFHt3OriqqvwqJkRGJBbRTwKZ8sWZPXuWTDAjorEXTcaPTyswlLFK1qyM5W1Rz9jzeFPOe48SUxAXaa3nMSYxpdTN6DqFYIRoiwee+wx7r//fubNm4eiKDRo0IBnnnnG3836R9y6m1RHKjmeHGyaDZtWQ/vtSpbsSuOlfW/x0dEvqGuLYn6nGYxoMCj3AqSnTK9hUTWibRFE2yLKtL9u6qS784L39NxRd+/Iuzd49/5MyA3e092ZGBS9gkKd3OA9Km/0PV8QXzB4jyDSGlbuq0MI/0pNTWX48OF07doVa76L/bV+kKWSJTtT+U/iWlYd3kCObufS+v2Y1mIi7eu08nfThBCVrMRL5Dabjd69e/uqbbZu3bpaB+JqSgqh3/1ESHLG6RHs/NXFU9NQjMInMJ6wOr6iZ9ldOxcRYOeligcXW7m4OjNNk61p21l1eANfn/gBj+nhgqgePNjuNgbUvUDSJEW1FxsbywcffOCrlRESUr2nV6Q50zmafRJVUQm2Vu/PUlW4DQ+rDq/ntb/fwa47mNRsHLe0mFgpU3E0RctNV48o0/66qZPhzvIF695U+dyU+XzbDuYc4ff0naS5MkoI3kMKjLRH5htpP3MkPsoWLsF7FXfnnXf6uwm1WpLjFMsPrmbtkc9wGW4ubzCAKc2vpnVoc383TQjhJ8UG41lZWTz00EPs2LGDDh06YJomu3btolOnTjz55JOEhla/OYfhs2cTtGEDAKaq4omM8C3bZW/X2jeq7Qu26+amitfStTezPTnEHf+GVYc3sDfrAHUsIVzdZCTjmwynRYjUDRA1x6lTp3jhhRc4ceIES5YsYd++fWzbto3x48f7u2lnzWN4yMhJJUgLqpEXB/3h15TfeWrPq+zPPsi/onryYLtbaRES6+9mFUtTNN9Id1kYpuEN3gsF7AVH4g/lHCPevZs0d3qBQnX5hWrBvmDdG8B757wXHH3PC+LDsam18++rv/Tu3ZtTp07x559/AtC1a1eio6P93Kqa76g9ibcOfsBHR77AQGdEg0FMbn41zUOkmIsQtV2xwfgTTzxB69at+b//+z/U3JRq0zR55ZVXmDdvHs8++2ylNbK8pD33HCdGX0pO3Rg8EeGgyYhuUfZlJfDB4Q2sP7aRbD2H9nVa82iHe7i8wcUEa8WvKS6qpvaRCprMGS/RzJkzGTNmjC9Vs3nz5txzzz3VMhgHQEEC8XJwzHGCBX8t5ssTm2gUGMOLXedySb0Li62J0T5SISDASlnT1asKVVGJsIURYQujZRkG+g3TINOTVahA3Zkj8UccSWzP+Is0dzqeYpZXDNGCvQXq8o2uFzUSn1fELkCT4P2f+PTTT3nuuefo3bs3pmny+OOP88ADD3D55Zf7u2k10qGcoyxJWMX6Y18BCqMaXcbNzSfQJKiBv5smhKgiig3Gt27dytNPP11gm6IoTJ8+ncsuu6zCG1YRzDp1cLZthUeRP+Znchtuvjn5E6sObWBLWjw21cqQmAFMaDKSLmHtpCBbNTapg6wzXprU1FSGDRvG4sWLAbBYLL6LkKL2ceou3j64hiUJ3uXu7mh5A5OajSOwlHn3kzpoRISH1PglHFVFJdwaRrg1jBZlCN5N0yTTk1WoQF2KK42UfHPejzmS2JnxF6klBO/BWlCxBeouiepOd7qV86etWV5//XXWrFnjGw1PSUnhxhtvlGC8nB3ITuTNAyv5LOm/aIrG+MbDuan5eBoESuE8IURB51RW1SxiCS5RPR13nGTtkU9Ze+RzTrlSaBzUgHtaT2FUo8vKnOIoRHUXHBxMamqq76LT77//Tp06dfzcKlHZTNPk25ObeXbvGxyxH2dw/f7c12YqjYJi/N20ak1RFMKsdQiz1qEFpU9x8gbv2fkK1KXnptCfTptPdaWT5DjJ7sx9pLjS8ZgedtXvz+LOIyvhE1VfpmkWSEuPiIiQc7py9FfWAd488B5fJm0iQLVxbdNRTGo2jnoBMhVACFG0YoPxHj16sGjRIu64444Co6KvvPIK3bt3r4y2iQpimia/pGxj1eENfHtqM4Zp0r9ubyY0GUnf6J6osvRRjfLkbx404EmZmlasmTNnctttt5GYmMjVV19NamoqCxcu9HezRCU6kH2IZ/56jZ+S/0erkFgWn/c0F0T1OKvXePI3DzZrBvd3r5g21hbe4D2UMGsozSm94zJNkyw9hwjJZilVv379mDx5MsOHDwe8aesXXXSRn1tV/e3M2MviA+/xzcmfCNGCubn5VVwfO6bMRReFELVXscH4I488wuzZsxk8eDAdOnQAYNeuXXTs2JEnnnii0hooyk+GO4uPj33JB4fjOJhzmEhrOJNixzGuyXCZv1SDZbplnfGS6LrOb7/9xooVKzhw4ACmadKiRYsCy/6Imivbk8MbB95jReJHBKo2ZrS9haubXHFO63FnusFiGHgn7YvKoigKdSwhaKbL302p8h588EG++OILtm7dCsCECRMYPHiwn1tVff2RvovFf7/HpuRfqWMJ5dYW13Ft7JWEW8P83TQhRDVR7NlGaGgoL730EomJiezbtw+AGTNmEBtb9gqy33//PfPnz8cwDMaPH8+0adMKPH/06FEefPBBMjMz0XWd+++/nwEDBvDJJ5+wdOlS33579uzho48+8l0UEGdnZ8ZePji8gU+P/xeH4aRbeAdu6fQAg+v3l2I4otbTNI0NGzZw44030qZNG383R1QS0zSJO/4N/7d3CSddKYxqeBl3tb6Z6IBIfzdNiAo1ZMgQhgwZ4u9mVGtbUv9k8YF3+TllGxHWMO5sdSNXN72COpWw1KEQomYp9dJ/bGxsgQD8wIEDLF26tNTRcV3XmTdvHsuWLSMmJoZx48YxcOBAWrdu7dvntddeY+jQoUycOJF9+/Yxbdo0vvnmG6644gquuOIKwBuI33HHHRKInyWn7uLLE9+z6vAG4tN3EagGMLzhQK5qPIIOYa1LfwEhapHzzjuPefPmMWzYMIKCgnzbO3Xq5MdWiYqyK2MfT+95lW3pO+gc1pb/6zaXruHt/d0sISrMNddcw/vvv0+PHj0KTD00TRNFUXwj5aJ4eVP83jjwHv9L+5NoWyT3tpnCVY1HEGwJKv0FhBCiCMUG47t37+bZZ5/lxIkTDBo0iGuvvZbHH3+cP/74g5tvvrnUF46Pj6dZs2Y0beot1jJ8+HA2btxYIBhXFIWsrCwAMjMzqV+/cJXJuLg439wmUbrD9uOsPryBj45+QZo7g+bBTXiw7W2MbHgpYdbqtza8EJVh165dAAXmiSuKwn/+8x9/NUlUgDRXBi/vX87aI58Rbq3Dox3uYVSjy6ROhqjx3n//fQC2bdvm55ZUP6Zpsin5VxYfeJ/49F3UD6jLg21vY2zjoaWusCCEEKUpcc74NddcQ/fu3fn+++8ZNWoUo0aN4vnnnycgoPTOJykpiQYNTs9DjomJIT4+vsA+06dPZ/LkyaxYsQK73c6yZcsKvc6nn37Kq6++ejafqdbRTZ0fk7ew6tAGfkj+DVVRuKTev5jQZCS9I7vJsmS1XLe6ss54ad555x1/N0FUIN3UWXPkUxbtf5ssTzZXN72C21teX+4XKLvVVQgMsAHucn1dIcpLYmIiDRo0wGaz8csvv7Bnzx5GjRpFWJjMcT6TYRr89+RmFh94j12Z+2gUGMPD7e9kVKPLsKkyxU8IUT6KDcZdLhdjxowBoGXLlrzzzjs88MAD5frmcXFxjB49mptvvplt27bxwAMPsGHDBt/6vn/88QdBQUG0bdu21NfSNK3Ach1FMQ0D+yELEaE1Y8muZGcqqxLW8+7fH3Eo5xj1AqP5d4ebubbFlTQIqnprWWoWjYjwmvHdVye3ng+urBSio6KxBgb7uzlVUmpqKq+88gr/+9//UBSF8847jzvuuIPISJk/XN1tTdvO07tfZXfWfs6P7MrMdnfQJrR5hbzX1W01IsKDa/w646L6uvPOO1m7di0HDx5kzpw5DBw4kPvuu48333zT302rMnRT56ukTbyZsJK9WQeIDWrEvI73MrzBoHMq7CiEECUptldxOp3s3LnTt/6kzWYr8Li0uZQxMTEcP37c9zgpKYmYmIJrta5Zs4YlS5YA3qXUnE4nqampvqD6bFLUdV0nOTm5xH1Mw0D3eKr1iZJpmsRn7GbVofV8kfQ9btPN+ZFduavVzVxS71/ePxQuSHNVvc8YER5erb/76izA1ElOScYaYC9xv4YNG1ZSi6qWe++9l169evHSSy8BsH79eu655x6WL1/u34aJc3bCmcz/7V1C3PFvaBBQj+e7PMTg+v0lU0jUaqqqYrFY+Oqrr7juuuu4/vrrGTVqlL+bVSV4DJ3Pkv7LkgMrOZBziJYhsTzV6UGGxAzAomr+bp4QooYqNhivV68eTz31lO9x3bp1fY/LMpeyS5cuJCQkcOjQIWJiYoiLi2PBggUF9mnYsCGbN29mzJgx7N+/H6fTSVRUFACGYfDZZ5/x3nvvnfOHq0lydAefHf8vqw5vYHfmPkK0YMY1HspVTUbQKrSZv5snqrC5P3tQgRdknfFinTx5kjvuuMP3+Pbbb+ezzz4r07GlrRoB3uk2ixYtQlEU2rdv7+sLjx49ysMPP8yxY8dQFIXFixfTpIn8j/on3IabdxI/YvGB9/CYHqa1mMjNzScQrAVW+HvP/dmD1ZrOwz0r/K2EOCcWi4UNGzawbt06XnvtNQA8Ho+fW+VfbsPN+mMbWZqwkkP2Y7QNbcHzXR5iUP2+aIoE4UKIilVsMP5P51BaLBbmzJnDlClT0HWdsWPH0qZNGxYuXEjnzp0ZNGgQM2fO5OGHH2b58uUoisLTTz/tG7X47bffaNiwoa8AXG11IPsQHxzewCfHviLTk02b0BY80v7fDG8wUKp3ijJxGbLOeGn69u1LXFwcQ4cOBeDzzz+nX79+pR5XllUjEhISWLx4Me+//z7h4eEFMngefPBBbr31Vvr27Ut2drZvio44N5tO/cazf73OwZzDXFz3Ah5oeytNgisv28NlgOExkXXGRVX11FNPsXLlSm699VaaNm3KoUOHfKvX1DZO3cW6Y1/wVsIHHHOcoGOdNizsOpcB9S6Qoo5CiEqjmHl559Wcy+UqU5p61oFtOJWqXXjDY+h8e2ozqw6v55eU37EoFi6L6c+EJiPpHt6x2qZZSpq6f8z6yYNqGiy6qgPWgJLnjNfWNPUePXpgt9vRNO8oiK7rviXOSlr2Z9u2bSxatIilS5cC8MYbbwBwyy23+PZ59tlnadGiBePHjy9w7L59+3jkkUd8VY7Loiz9nMflIOfQDlxVvJ8rT4dyjvLsX2/w3amfaRbchAfb3kq/uudXejtm/eTBomk83qd69tHVnc10Edq8G6pW8rze2trPVRdl6eecWem4kvbiVM6+mrldd7D2yGcsP7iaE85kuoV3YFqLa+kX3avanl9VNjmf8w9T9xAcYCEktkuJ+0kfV71IJYoq5KQzmbVHPmPNkc844TxFw8D6/LvVTYxuNIToACkkJURFOdflfsqyakRCQgIAV199NYZhMH36dC666CISEhIICwtj+vTpHD58mAsvvJD777/fd0FAlC5Hd7D0wEreTlyDRbFwd+vJXB87Gqtq9XfThKhS7rrrLhYuXMjIkSOLfH79+vWV3KLKl+Oxs+rwBt5OXEOKK41eEV15otMM+kR2lyBcCOE3Eoz7mWma/C/tT1YdXs/GEz/iMXX+Fd2Th9pP56K6vWW+khDVnK7rHDx4kHfeeYfjx49z3XXXsX79ejweD1u2bGHdunU0bNiQe+65hw8//LDQCHp+ZVk1wuNy4DqqEVyn5q5cYJomG45sZH78yxy1JzE69nJmdb6DBkH1/Noui5aGoiiyaoSfuDJTiI6OLnVkvDZ66KGHAHj99df93JLKl+nJ5v3Ej3nn0IekuzP5V1RPpra4hp6RJY8uCiFEZSj2L9amTZvIzs7m8ssvL7D9888/p06dOvTt27fCG1eTZXmy2XBsI6sOr2d/diJhllAmNh3FVU2GExvc2N/NEzXI+TEKlhoxGaXqKcuqETExMXTr1g2r1UrTpk1p3rw5CQkJNGjQgA4dOvjqYgwaNIg//vijxPcry6oRHpcDj66TU0NTCPdmJfD0nlf5LfUP2oe24qleD9IjolOVWEWiR12DoMBASd/0E5vp/f2QNPXC6tf3LndqGAb169cnIMCb3u1wODh16pQ/m1Zh0t0ZrEj8iPcOfUymJ5uL6vZhWouJdA1v7++mCSGET7F/sV555RVeffXVQtt79+7NbbfdJsH4Ofor6wCrDq1nw/GN2HUHncPa8njH+xgSM4BA7eznPglRmjGtNAJM3d/NqJHKsmrEpZdeSlxcHGPHjiUlJYWEhASaNm1KWFgYGRkZpKSkEBUVxS+//ELnzp399Emqvgx3Fq/+/Q6rDn9CqCWEh9vfydjGQ6tU9tCYVrLOuKja7rrrLlauXOl7rKoqd911F2vXrvVjq8pXsiuNdw6uZeXh9eTodgbV68u0FhPpENa69INFIYrTSUDiYQISEglMSCTg4CFsHg8RtbwKvz+YpknWuJFwrWR11CTFBuMul8u3zFh+UVFR5OTkVGijahq34earEz+w6vB6tqXtIEC1MTTmYq5qMoLO4e383TwhBLBlyxYOHjzoC5qzs7NLXc2hLKtG9O/fnx9//JFhw4ahaRoPPPAAkZHeGhAPPvggkyZNAqBTp04lpqjXVoZp8NHRL3hp3zLS3ZmMazKM6S0nEWEL83fThKh2dF3HZjtd3NFms+F2u/3YovJz0pnM8oNrWH04DqfhYkjMAKa2uIY2oc393bRqQc3JISA32A48cJCAg4cISDiI7ehxlNxaz6aq4mrUECLC0XQJxiudCarDgSQ71izFBuPZ2dl4PB4sloK7uN1unE5nhTesJjjmOMHqw3F8ePRzUlxpxAY14v4207iy0WDCrXIiKSqHt5o6LLrK3y2puhYtWsT27ds5cOAAY8eOxe12M2PGjAIjSMUZMGAAAwYMKLDtrrvu8t1XFIVZs2Yxa9asQsf27du3VhROOlfx6bt5es8rbM/4ix4RnZjZ9vYqPbrlraaeJtXURZUVFRXFxo0bGTRoEABff/217+JgdXXMcYK3Ej7go6Ofo5s6wxoMZErzq2kRUruXxi2OlpFBwIFEAg7mjnTn3mwnTvr2MSwWXE0bY2/bmrTLBuFs3hRH82a4mjRm5v9UWTXCT3zV1P3dEFGuig3GBw8ezCOPPMIjjzxCcLB3OaTs7Gzmz5/P4MGDK62B1Y1hGvycso2Vhz7h+1O/AjCgXh8mNBnJBVE9ZO1KIaqgr776inXr1jF69GjAO887Ozvbz62qvZKdqSzc9xbrjn1JPVsUT3V6kGENLpGKx0L8Q4899hj3338/8+bNQ1EUGjRowDPPPOPvZp2TQ/bjvJrwIZ8c+xqAKxsNZnKzCTQJrn01AQoxTSwpqb5A2xt0e0e7rSmpvt2MgACczZqS3b0LKc1jcTaLxdEiFlejRmApbgqQjIgLUZ6KDcbvvvtuXnzxRS655BIaN26MaZocO3aMcePGFRj1EV7p7gw+PvoVHxzeQKL9KJHWcG5ufhXjGg+jUVBM6S8ghPAbq9WKoii+YE+m4viH2/Cw8vAnvLb/HRyGi5uajWdai4mEWIL93TQhaoTY2Fg++OAD38XGkJDqOcb2xP+eZvlf76ApGuMaD+Wm5lfRMLC+v5tV+UwTa9JJAhIO5s7nPj3SbcnM8u2mhwTjbN6MzAvOx9k8FmeLZjiaxeJuUB9UGSQSwp+KDcYtFgv3338/06dP5+DBgwA0a9aMwMDASmtcdbAj4y9WHVrPZ0nf4jRc9IjoxO2tbuDS+n2xqbbSX0AI4XdDhw5lzpw5ZGRk8MEHH7B27Vquukry+ivTzynbeGbPq+zPTqRvdC8eaHurpJkKUc5OnTrFCy+8wIkTJ1iyZAn79u1j27Zt1apehWmaHLcncX2TkVzXfAL1A0pe7rFG0HVsx457R7kP5Au6Dyai2R2+3TwR4Tiax5I+aIB3lLt5LM7msXjqRoNkFglRJRUbjH/55ZcFHiuKQmZmJu3btyc0NLTCG1aVOXQnXyR9x6rD69me8RdBWiBXNBzMhCYjaFunpb+bJ4Q4S5MnT+bHH38kJCSEAwcO8O9//1tWjKgkR+1JPL93MV+f+IEmQQ1Z2O1RLq57gaSkC1EBZs6cyZgxY3zrjTdv3px77rmnWgXjiqKwqN//4Urai1OpWavQKG43tsNHc1PLDxKQ4C2iFnDoMKrrdKE9d91oHM1jSR1+uW8+t7NZU/TICP81XghxTooNxv/73/8W2paWlsaePXuYP38+F154YYU2rCo6lHOUVYc3sO7oF2R4smgVEsvsdncwouEgQi3VM9VL1Hz9Gsk642XRt29fCcArkUN3svzgat5K+ACA6a0mMSl2HAFa9c0o6tdIITgwAHD5uylCFCk1NZVhw4axePFiwJsFqZYhTfn7779n/vz5GIbB+PHjmTZtWoHnly1bxurVq9E0jaioKJ588kkaN24MwLPPPst3332HYRj07duXhx56qNZfbFMcjoLLheWlmB8+gqIbvv1cDRvgaB5LVu+eOJvH4mjmHek2Qv13zin9nBDlq9hg/Kmnnipy+5EjR7j77rtZvXp1hTWqKtFNnU2nfmPV4fX8mLwFi6IxqH5fJjQZSc+ILrX+D4qo+oY3l3XGS9OjR49Cv8t16tShc+fOzJw5s9QlzkTZmabJf09u5tm/XueoI4khMRdxX5upNKgB8z2HN9eICA8iLV1OUkXVFBwcTGpqqq+/+/3336lTp06Jx+i6zrx581i2bBkxMTGMGzeOgQMH0rr16ZUNOnTowNq1awkKCuK9997jueee48UXX2Tr1q1s3bqVTz75BICJEyfy66+/0qdPn4r7kFWImp3tHd0+mK+IWsIhbMfyLRemqTgbN8LZLJaMi/rmzuduijO2KWZQ1ZsaKv2cEOWr2GC8OI0bN8bjqfmVFJNdaXx05HNWH4njmOME9QOiub3l9YxpPLR2zE8SNYbDY2ICVe9PetUxadIkGjRowIgRIwCIi4sjMTGRTp06MXv2bN555x0/t7BmOJCdyDN7XuenlP/ROqQ5S857ht5R3f3drHLj8Bg4cpwobjemooKqeOdpykVbUUXMnDmT2267jcTERK6++mpSU1NZuHBhicfEx8fTrFkz30XJ4cOHs3HjxgLB+AUXXOC73717d1/wrSgKLpcLt9uNaZq43W7q1q1bAZ/Mv7T0DF+g7U0v9450206c8u1jWK04Y5tg79CWtMsv9c3ndjVphGmrPhlBDo+JwyPpdkKUl7MOxv/++29s1ajTOBumafJ7+k5WHV7Pl0mb8Jge+kR1Z0bbWxhQ9wKs6ll/XUL43WO/6t51xpv5uyVV1zfffOM7eQSYMGECV155JTNmzPDNrRTnLsuTzRsH3uPdxI8I0gJ5sO1tTGgyEota3NI51YzHg+pyMe9/GprNzuO9LSi6B8VtgEcHTBTAVBTABE4H576gHQVU5fRjqXAsypmu6/z222+sWLGCAwcOYJomLVq0wGq1lnhcUlISDRo08D2OiYkhPj6+2P3XrFnDRRddBHizjvr06UO/fv0wTZPrrruOVq1alc8HqmymiSU5pWBqee7cbktaum83IzAAR7NYsnt0I6V5XhG1ZrgaNihhubDq47FfdSxauqwzLkQ5KTa6vPXWWwttS09P5+TJkzz77LMV2qjKluOxE3f8G1YdXs9fWQeoYwlhQpMRXNVkOC1CYv3dPCFEBQsKCuLTTz/l8ssvB+Dzzz8nIMBbGEimopw7wzTYcGwjL+57i2RXKqMaDeHfrW8i2hbh76b9c6aJ4nSi6DqmzYanbjRGoB3VasXTIKLgvoYBhoFimGCaYObeNwzQdRSPxztPVNdRdP10EK+cDtwVE7w5LoCiFBh5N1XVO/qe91OIImiaxoYNG7jxxhtp06ZNhbzHxx9/zPbt21mxYgUABw8eZP/+/Xz33XcA3HzzzWzZsoVevXqV2M7o6JIzEB0BGidOakSEhZdf4/MYBtrxJKz7D2D9+wCWvxOw7k/A+vcB1HzLhRl1QnG3bIFj4EW4W7bA07I57lYt0BvEFLiYpgHBubeawKKloSgKEeEV8N2LEhmGB9PpLPX3Q1QvxQbjN998c4HHiqIQERFBs2bNyjwyXlrBj6NHj/Lggw+SmZmJruvcf//9DBgwAIDdu3czd+5csrKyUFWVNWvW+E6Oy8vf2YmsOrSeT459TbaeQ/vQVsztcDdDG1xCsCZJvULUFs8//zzz58/nscceQ1EUunfvznPPPYfD4eCRRx7xd/OqpZ0Ze3lqzyv8kb6LzmHteKnbo3QOb+fvZv1zuaPgAHqdUIw6oZi+v02Ooo9RVVBV8id2linJs0AQf0ZAXyCI93iDeJfLe4wCBYJ4Je8dVcx8qfMSxNc+5513HvPmzWPYsGEEBQX5tnfq1KnYY2JiYjh+/LjvcVJSEjExMYX2++mnn3j99ddZsWKF7zzxq6++olu3br71zPv378+2bdtKDMZ1XSc5ObnEz+HMSscwdNLS00vcr0QeHdvRY/nmc+eOdB9MRHU4fbu5IyNwNosla9DFOFucLqLmiY4q+vcmM/Pc21QNeHQdi6b9s+9enBNT9xAcYCn196Nhw4aV1CJRHooNxnv37l3k9i1bthAXF8fcuXNLfOGyFPx47bXXGDp0KBMnTmTfvn1MmzaNb775Bo/Hw4wZM3juuedo3749qampWCzlkyLuNjx8eeoXVh1ez2+pf2BVrAyJuYgJTUfSNay9jIIJUQs1bdq02HT0kk4aRWGprnRe3r+ctUc+I9IWzryO93JFw8GoSjVOuzYMFKcLxcg3Ch4cBFoFp5yeSxBv5o64m2bhIN7QUTw6eDwohomie7zbcoN4RVFyX9/MHYknN6bPC+LVgqn0Mh++2tm1axdAgXniiqLwn//8p9hjunTpQkJCAocOHSImJoa4uDgWLFhQYJ+dO3cyZ84clixZUmDUrlGjRnzwwQd4PB5M0+S3335j0qRJ5fypSqa4XPmWC8stonbwEAGJh1Hdp5cLc9Wvi7N5M1JGDvUuFda8Kc5msegRMgIshKg4ZYpwd+7cyfr16/niiy9o3Lgxl112WanHlKXgh6IoZGV5U34yMzOpX99bTffHH3+kXbt2tG/fHoDIyMiz+1TF+OTv9cz58SFOulJoFBjD3a0nM6rRZUTVhJRJIcQ5czqdrFmzhr179+J0nh4RKW5VCVGYx9BZcySORfvfJlvP4dqmo7it1fXUqcbLPiputzdQVZTcUfA6mAFVvGaKovguEpxTEJ9vJN6XSm8ap4N43Sg8Hz5fEC/z4au2hQsXEhUVdVbHWCwW5syZw5QpU9B1nbFjx9KmTRsWLlxI586dGTRoEM8++yw5OTncddddgHdk7vXXX2fIkCH8/PPPjBw5EkVR6N+/PwMHDqyIj+ZdLuzgoTPmcydiO3rUt1yYqSi4GjbA2TyWrD69fEXUnM2aYoRU375KCFF9FRuMHzhwgLi4ODZs2EBkZCTDhg3DNM0yVxUuS8GP6dOnM3nyZFasWIHdbmfZsmW+91YUhcmTJ5OSksKwYcOYOnXquXy+AhIyEugS1oYxTYbTN7oXmlL9C2kIUZpBTVWsplH6jrXYjBkzaNmyJT/88AN33HEH69evp2XLlv5uVrWxJfVPntnzKnuy/qZPVHdmtr2dVqHVtGJg3ii47sEMCsQTUx8jKLBMAeTAtsEEh1TTmaF5Qbym+QL3MqfS5wbyhYL43FR6DKNwEF9gPnzubPjcUXaZD1/+vvnmG2bPnu1bV/zFF1/kvPPOK/PxAwYM8E0jzJMXeAMsX768yOM0TWPevHnn1OaSWBISCPzmK7SDx3xF1KzHT+RbLkzD2aQRjpbNSB94kXepsBbNcMY2yTetRJyLQU1VgoMCAWep+wohSldsMD506FB69erFG2+8QbNm3pOq4jrbcxUXF8fo0aO5+eab2bZtGw888AAbNmxA13X+97//sWbNGoKCgrjxxhvp3LkzF154YbGvVZaCH48NepTDv3+LLbR8RtrF2dEsmhT88INx4eDKSiE6KhprYDUNFCpYYmIiL730Ehs3bmT06NGMGDGCa6+91t/NqvKSHKd4Ye+bfJb0LQ0D67Ogy8NcWr9ftZzu4xsFV1X0sDoYISFnPQo+sG0wkZGRpKamVlArq6C8ixTnEsSf9Xx4s3BRu3zz4ZVAGXEvzv/93//x7rvv0qpVK/744w+ee+45X5G16qjhNdehJSdj2Kw4mzYhp2MHnMOH+OZzu5o0wiylSrw4N5c2VYkIDyQtXYJxIcpDscH4okWLiIuL44YbbqB///4MHz4c0yz7uoJlKfixZs0alixZAniXv3A6naSmptKgQQPOP/98XyrVRRddxI4dO0oMxstS8MM0DHSPR4pO+ElEeLh8936Q7jQJQMeakow1wF7ivrW16EdeTYqwsDD++usv6tatW2p/Upu5DBfvJH7E4gPvoZs6t7S4lpubX0VQdSt8aRjeQk2mgRkYcFaj4EXJcOgoOZ5ybmQNda7z4c8YhS8wHz7YKinwxbBYLL4lxbp160Z2drafW/TPHFu9CnfSPrIaxVZ87QZRQLrTBIdk2wlRXooNxi+99FIuvfRScnJy2LhxI2+//TYpKSnMnTuXwYMH069fvxJfuCwFPxo2bMjmzZsZM2YM+/fvx/n/7d17fBT1vT/+1+zM7D23DcmGS8ALiAoR/RU5WoRouGmQcgvailVRDpZKpRcEQYs99CGClh45cgQRDR6pWkQUIdaen6EVj+IFDzVS2oMXIkFMlCRArrs7M5/vH5tdshCSEPa+ryf6MNmd2f3MrPNh3/P+fD5vjwculwvXXHMNNmzYgJaWFqiqio8++gh33HFHWA6YKNWs+LitzjhHXZ/RzTffjOPHj+PnP/855s6dGzL3kUK9c/RDPHpgHb5q/hpFOd/HgovuRj9bXtc7xhHJ64Xk8/mz4Jnp/iy4+dyzaI++VQ9FbcBvJmSeeyPpdIEF484QxBsOtZtp+dRTW1sbnArY0e+zZs2KRbN6TOvXFz61GeB0w6hb8bEORT7BOuNEYdLlAm52ux2TJk3CpEmTcPz4cbz55pt4+umnuwzGu7Pgx/33348HH3wQGzduhCRJWLFiBSRJQkZGBu644w6UlJRAkiSMHj0a1157bbiOmYgoyDAMOBwOZGRk4Morr0R5eXmsmxSXDjV/jUcPPIVdRz/AefZ+WHfFcnw/+3uxblb3GQZMbXXBdbsderYLhtXCTCqlhJtuuikkG37q70REFBuSOJux53HM6/V2a5h648G98EhxvhpukuIw9dhY/J4GkzCw5qZLoFo6nzOeqsPUp02bhq1bt8a6GV3qTj+neVvRXPV3eMPUzzXrrdhw8EU899UrUE0KfnLBTMzMnwLVlBjzMSWvFyafD0KWoWekw7Dbw5IF78iDO45CURVmxmNEdajIElldltFL1X4uUXSnn/M0Hoe35jN4JC7GFk2GoWPxbg2yrODXw/1zxiVIEO2GpATWDDHBBAkSJEny/yxJkBK5xGUcCNQZd/Qv6HQ79nGJJTzFuxOIsJhhOtYEQGq3+IsEIZsgZDk4j42IUsf3v/99PPPMMyguLobNZgs+npmZGbtGxZgQAm/WvI1Vnz2Nbz1HcWPeGPxi0F3IsXS+UGZc0HV/FlwI6DYbvL1cEFYrV+MmIuoBn+6FJjTIkgzFpMKimNHHkQ0BAUMYEG1/DGHAEAZ0Q/f/V+gwDAM6dAhDQBd6h6/fPqCXIMH/j/+PCSZ/dUQG9JSkUisYlyT4+vWBL8PjX621rdwKNB8krw+SzweTzwdoWtuXtpOrtgYCdWEycbEQoiTzxhtvAAD+8Ic/BB+TJCllh6wfaPgSK/5vLfYcq8DFaQPxu4IluDxzSKyb1SXJ44VJ82fBNVcWDLsN4IrKRERnTwi0Gq3QDR1W2YpcWy6sshWKVAsJElS5Z32rEO0CeBEazAsI6IYOAQHN0EKCex26/7kOBvRKge/qbX8CAXwgmA9k6CVI/pEzvDFLcSS1gvGAdqu4+i9pW+jzgdIqugFJ1/2lVbw+SD4NkuaD5PEgEKpDiJO1UE0mCJMMyLzQKX4UDzBBAVc+7czOnTtj3YS4cMLXgP/84r/wx8M7kK468euL78W0vtdDjudFkgJZcAC63Q5vTuyy4Ndf4oDD6QB4vRFRgjIMHR7DPwQ9TU2D0+yEWT457WnaQAccjp73c5IknfPfKYYwIIQICeiNtvaEZOdhhAT3utCD+wL+4D0QyJ823L5dhj6YlW8L5v3P8Xs+hUdqBuNdkSRAUSCUMyzMGiitoun+ciq64a9R69Mg+byQWr3+kisCwQy7kNoy67KJQ+Epqkb1NcGSFCtDRE5LSwtKS0vxzTff4Le//S0qKytx8OBBXHfddbFuWlToQserR/6MJz7fiOO+BszoNxHzLrwNGWp6rJvWMSH8c8E1DUJR/Flwhx1QYvtX2jUX2pCVlZFadcYpIbRfOb0jibaaOoWfpvvgEz7IkgyX1QWbYoNiOr1PHdc/9v2cP7vd8/0DgbwhTgbwQoiOA/q24faB4N5n+GDA6Fa5547mzwcDeg63pzYMxntCkgBZ9g9dxxkC9rbMeiBYh6YFFxKSvF5A1wHp9HnrHApP4fZdi4BZAP1j3ZA4tnjxYgwZMgR79+4FALjdbsyfPz8lgvFPjv8Dj/zzP7G/4TP8f5lDsXjwTzE47cJYN6tjmg6TtxWSAHSHA97cXhAWS9xkKI426vDJPnBgPMWbwMrpBw8exKeffoqioiIAwF/+8hcUFHS+GBQlsbah6IYwYDFZgkPRpU761JpmHa2qD9YoNjPcQoas91D7gD7kZ5zM2AfnzAsdujBgtAvouzN/vn1bJUiAYYChW/LhJxopwWBdDQnWg5eeYYTOW9c1SB4vJJ/mn7fe2nr6vPXAUPjAQnNx8gWU4tvv97bVGR8U65bEr0OHDuHxxx9HWVkZAMBms3XrrnciO+qpw+OfP4vXv/n/kWvJxoqh9+MG97WdfgmLiXZZcENVoPXKhmGzxTwL3pHH/8o64xSf5s2bBwCYOXMmtm7dCqfTGXz87rvvjmXTKAa6Goremd+8Xw9FacATozMj2ML4F66Avv38+VMD+vZD7IUQ0HUfnKqz4yQgJaz4+zaTKk6btw4grd3z7eatw9AhaZp/GLzXd/q8df8O/qHwMuetE50ts9mM1tbWYCB66NAhmM3JWQLRZ2h4sWob1n65CR7Di7vOuxn/et6PYFdsXe8cTW1ZcADQnU5oac64yoITJaKjR4+G9G1msxlHjx6NYYsomjTdB5/hg8lkQpY1C3bF3uFQdIqOs54/bxjIsjvQeeE/SjS8AuNVu3nrQAdD4QPz1gNZ9TPNW4cESQgICZy3TnQG8+bNw+zZs/HNN9/gV7/6Ffbu3YtHHnmkW/vu2rULDz/8MAzDwIwZMzBnzpzTtnnjjTewZs0aSJKEiy++GKtWrQo+19jYiOLiYowdOxZLly4N2zF15P3a/8WKA2vxZdMhjMoegYWDf4IB9r4Rfc+zIoT/RqOuQ8R5FpwoEU2ZMgUlJSUYN24cAOCtt97CtGnTYtwqiqhTh6I7uh6KTkTRw284iSpk3rra8ZCVUxaZC8xblzQNpsC8dbTNT+G8dUph11xzDYYMGYJPPvkEQgg88MADcLlcXe6n6zqWLVuG0tJSuN1ulJSUoKioCAMHDgxuU1lZifXr1+PFF19ERkYGamtD72k//vjjuPLKK8N+TO193VKN3x1Yj/Lv3kW+rTeeGPZvKMy5KqLveVYCfRIEdKcTRnoahNmcmFlw4R9aCCDky67UbrUhfgmmWBBCYMqUKRg9ejT27NkDAHjkkUdw6aWXxrhlFAmGocMrvBBCwKk6kWZO6/ZQdCKKHgbjycxkgjCb0Fmwftq8dW/77Hqrfyh8W6AOgCXcKCn95Cc/wY033oiioiLY7fZu71dRUYEBAwYgPz8fADBx4kSUl5eHBOObN2/GzJkzkZGRAQDIzs4OPrdv3z7U1tZi1KhR2LdvX5iO5qRW3YPSr17Gs5V/hAQJP7vwDtzWfzos8fCFrH0W3Gz2Z8HttoS9CagbOnShwwQT9LbVQYR+sudtv0pvd7Uvu9Od5zvaNrAQUFevder+Hd0wONPz7UsDtXuw0+d5oyL6JEnCnDlzsH37dgwZMiTWzaEIaT8UPdOSyaHoRHGOV2cq62jeenunzlvXDX9mPRCst5xh3npgkTkG63Fh6gWsM96VO++8E2+88QZWrVqFgoICFBcX47rrroPFYul0v5qaGuTl5QV/d7vdqKioCNmmsrISAPDDH/4QhmFg3rx5GD16NAzDwMqVK/HYY4/hvffeC+vxCCHw1nf/g98dWI8jrTW43l2IXw6ajTxrbljfp0c0DSaPB5Ak6GlOGIG54AlKCIEWvQWSkPCjK3KR68pF/7Tu3VBov0hg+9Vz29fA7fbzZ3qtwM/tOvkz7Rcs89OuvzCMdj8HHhcnX6P9zYWO9gssRHTq813dqDibGxFCCEiShGxTNiSdf+d05tJLL0VFRQUuu+yyWDeFwimKQ9FvGexsWwBQC/trE6UiBuN0Zh3OW3eEbhOyyFzbQnNeXwfz1gFJViC1tPoXmZPlhM2AJZoReawz3pURI0ZgxIgR0HUd77//PjZv3owlS5bgf//3f8/5tXVdx1dffYXnn38e1dXVuPXWW7F9+3a8/vrrGD16dEgw3xVZlkMy6x3ZX/0p5v1tKd6t+xsuTr8Q/z5iKa7O+d65Hsa5MQxIrR5AGBB2O4ysDAi7PeH7AI/mgVf3wm1zw2VzYfiFMhRFgabxS+q56upGRfvHA4+pqgred+zcJ598gu3bt6NPnz6w2U4u2rh9+/YYtop6KjAU3RCGfyi6mgaLEtmbm6P6WpGVlRbTOuNEyYTBOJ2bbsxb9wfsOvS0dOhHZZg8XkheD6S28m3+WuvtVoNnoB5Whxv9dcZZ2axzra2t2LlzJ/70pz/h73//O6ZOndrlPm63G9XV1cHfa2pq4Ha7T9tm2LBhUFUV+fn5OO+881BZWYm9e/fi448/xosvvoimpib4fD7Y7XYsWLDgjO+n6/ppc85PNbvsbnx24jPcf9FPcVO/G6GYZBw7frzLY4kEyeeD5PX6s+AZ6TCcDgiLGdA04MSJmLQpHDRDQ6veCptiQy9bL5haTTjWegxf1bciMzMTGVJrrJuYkrKzs7u8PgCgd+/eUWhNfHrmmWdi3QQKg1gORf/qhIZ6yYOsqLwbUfJjME6RFRgKr6oQTgcMn/dk4iI4DL4tq+71tsuq+7/M+heXE/456iYG6j3xnxVtdcYvjnVL4tf8+fPx6aef4pprrsHMmTMxYsQImLpRbaCgoACVlZWoqqqC2+1GWVlZyErpADB27FiUlZVh+vTpqKurQ2VlJfLz80O227p1K/bt29dpIN5dTxb+B0TNV7CbO8+gR4xhQPJ4IekahM0KzZ0Lw2ZNiuoNhjDQorVAkRT0cfSBXQ1dX2Bl+SGo6jdYPfn8GLWQqHN9+/qrJ9TW1sLj8cS4NXRWhIDH8EATWnAoukW2nFOd655YsecYFKUx5euME4ULg3GKneAweAXCAsDR7outEP7V3/V2c9U9Xv+Ky20Z9bYN2xaTa8vQJ8EX/nDRDQ2a0GAIKep/WSeakpIS/P73v4fcdqNnz549KCsrw0MPPdTpfoqiYOnSpZg9ezZ0Xcf06dMxaNAgrF69GkOHDsWYMWMwatQovPvuuyguLoYsy1i4cCGysiKXU+jt6I1mtQ7eiL1Dx4JZcJMJenoaDEdbFjxJtGgt0IWOXrZeSDen85qihFReXo6VK1fi22+/hcvlwpEjR3DhhReirKws1k2jM4jFUHQiih4G4xSfJAlQVX9GHQgN1NsNfW+fUTd5vf7hr+0WLAmUaEv2QP1k4G0E51GaTWY4FAdUkw+qSYZqUmPcyvg1atQo7N+/Hzt27MCbb76Jvn37Yvz48d3at7CwEIWFhSGPzZ8/P/izJElYvHgxFi9efMbXmDZtWmLW+jUMmAJzwa0WaHluGFZLUl1rPt2HVqMV6eZ0uKwuXkeU0FavXo0//vGPmDVrFl577TW8//77eP3112PdLOoAV0UnSg0Rvap37dqFhx9+GIZhYMaMGZgzZ07I80eOHMGiRYvQ0NAAXdexYMECFBYW4vDhwyguLsb55/uH+g0bNgzLli2LZFMpkbQf+g4gZFG59rXVNd1fOsnrg8nnA3QNgOTPuksSRPsgPYGCh1MDbwkSVJMKh+qAVbFCkRQoJiWYuZOlozB1UdIoVR08eBBlZWXYsWMHsrKyUFxcDCEEnn/++Vg3La75qyr4/FnwzHR/FtycXEGqbuho1VphVszo5+wHm2LreieiOKcoCrKysmAYBgzDwFVXXYXly5fHulkU0DYUXRc6zCYzchw5sMpWjsQhSmIRC8Z1XceyZctQWloKt9uNkpISFBUVhdTfXbt2LW644Qbccsst+PzzzzFnzhzs3LkTANC/f39s27YtUs2jZHVqbXVnB4G6rrXLqHv9ZZbaVn0PCAbqshzT8myBwFsX/rrFXQXedHZuuOEGDB8+HE899RQGDBgAANi4cWNsGxWvdB0mrxeSYUC32aBnu5IuCw74V+Zu1VshhECOPQdp5jTWvqakkZ6ejqamJlx55ZVYsGABXC4X7HZ71ztSRAlhwGN4IISAQ3VwKDpRColYMF5RUYEBAwYgPz8fADBx4kSUl5eHBOOSJKGxsREA0NDQgNzcOKiBS8nr1EC9vUCJNl3zl2fz+DN/ptZWSIYBEfwyHsiom8IeqLcPvAP1c8MReM+6NA1OhYvedWTNmjUoKyvDbbfdhlGjRmHixIkhpZPInwU3+XwQsgw9MwO6ww6oyZUFD/DoHvh0HzItmci0Zp71kNA7RuQhPT09Qq0jOndPPvkkrFYrFi9ejO3bt6OhoQH33HNPrJuVsjTDB5/ugyRJyLQmxlD0WZemwZnmBOCLdVOIkkLErviampqQ+rlutxsVFRUh28ybNw933XUXNm3ahJaWFpSWlgafO3z4MKZMmQKn04mf//znGD58eKfv1536u0IInDhxAs4sZw+OiM5VYHhcwtH1tsXkDEDzQWr1BIN1CNH2LwCTdDKb3kWgrgkNmn4y4w0ATtkBq2qFVbFCNalhy3hPyAKU1lZo2dlJG0T11NixYzF27Fg0NzejvLwczz33HOrq6vDQQw9h3LhxuOaaa2LdxNjQdZg8HkhCQLfZ4O3lgrBaYzpKJJLalyrLc+TBIvcsIzWif3q3y2sRRdNXX32Fo0eP4nvf+x4AwGQyYerUqdizZw8aGhoS8+/mRJXgQ9FH5FmQleVknXGiMInp7beysjJMnToVd955J/bu3YuFCxdix44dyM3NxV/+8hdkZWVh3759uOeee1BWVgan88xBdHfq7wohoEka6pvYgcRCVlZWcnTequL/F/Bn1DX/YnLQfJA8Hv9QXq8PEgABAc3Q/XO8g6XZTFBlM6yKNTTjrZsAHfC2/QmXA/U+pCkK3PbaLoPxVK2/a7fbMWnSJEyaNAnHjx/Hm2++iaeffjrlgnHJ44VJ80EoCjRXFgy7Lalv4Agh0Kw1Q5Zk5Nnz4FAd5zQk/cB3zcjwmuFOnkXkKUksX74cv/zlL097PC0tDcuXL8e6deti0KrUkixD0Q/U+5Cmt6A3B9wRhUXEgnG3243q6urg7zU1NXC73SHbbNmyBRs2bAAAXHHFFfB4PKivr0d2djbMZv+3maFDh6J///44ePAgCgoKItVcop5pm1vuH9hsg8/wQTP8i6tB0yAZBixChk3IsGkmqLqAqhkwCQC6BOgCwqQDMvxzb5XwX5L/vvc4FEnC6vN6hf21k1FGRgZuvvlm3HzzzbFuSnQEsuAAdLsd3pzkzoIHtGgtMIQBl9WFDEtGWLJSj799GKpawzrjFHeOHj2KwYMHn/b44MGD8fXXX8egRalDM/yrokuQkGHJgEN1xP1Q9M78+97jUJQm1hknCpOI9QYFBQWorKxEVVUV3G43ysrKsGrVqpBtevfujd27d2PatGn44osv4PF44HK5UFdXh4yMDMiyjKqqKlRWVgbnnhPFi5DAu41ZNiPdnB4caq6a1NMybUII6MGh7zrg8wEej3/l9+bm4GrvMIzQYe8yb0NTmAjhnwuuaSez4A57RG4GxRuf7oPH8MCpOuGyumCWmcam5NfQ0HDG51pbW6PYkhRxylD0XrZesCm2hBmKTkTRE7FvXoqiYOnSpZg9ezZ0Xcf06dMxaNAgrF69GkOHDsWYMWNw//3348EHH8TGjRshSRJWrFgBSZLw0Ucf4T/+4z+gKApMJhP+7d/+DZmZmZFqKlGnhBD+Od49CLw7JEn+oEdRQhaSE/43azdHXQe8XsDr9Qfqra3+500mQIhgDXUG6tRtmg6TtxWSADSnA1p6LwiLJemz4ABgCAPNWjPMshl9nH1gV7iCNKWOoUOHYvPmzbjppptCHn/55ZcxZMiQGLUq+QSGohvCgEN1IF1NT8ih6EQUPRFNgxQWFqKwsDDksfnz5wd/HjhwIF566aXT9pswYQImTJgQyaYRdehMgbdFtiDdnA6bYoNiUrofeJ+tUwN1h780WzBQ17S2ld91wOPxZ9S9XkitrRA4WZxNBIa8M0indllwQ1Wg9cqGYbOlRBYcCC1VlmvLZakySklLlizBvHnzsH379mDwvW/fPvh8PqxZsybGrUt8muGD1/DCBFNSDEUnouhhT0Ep69TAW0BAghS9wPtsSZJ/MS1VPXOg3j6j3raYHHTdv188HANFj6bD5GkFJEB3OqGlOVMmCx7g1b3w6B5kWjKRZc3il2NKWb169cJLL72E999/H5999hkAf8Lk6quvjnHLEptHb4Vu6DDLZuTYcjgUnYjOGr+ZUEroKPA2wQSzbEaGOcO/qnk8Bd5n69RAvY0O4O4iFzKcTkBJwOOiHpEkCZLQoeVkw7DbU26EhGZo8OgeWGQL8tPyYVWsUXnfn3y/DzIyMuC/8ojiz1VXXYWrrroq1s1IaO2HotsVB9JtabDIlsT87tADcy9LR1paGgBPrJtClBQYjFPSaR94B+p4J1XgfZYu65vG2sepRFHg69cHPq9IqSw4EFqqzG13n3OpsrN1WR8nsrMzea0RJaH2Q9HTzelwmp0pOdrmsl5mZGXZUV/PYJwoHFKvF6GkcmrgLbX9sciWlAy8O1JxpBEZTTIGOGLdEooWYVb9q/SnkFatFZrQkGXJQqYlE7Ip+qMBeK0RJR+v7oFmaFBlFb2svWBX7Sk9FL3iqBdpnmacz3XpiMKCwTglDAbePbPuvSNQ1e9Y+5iSks/wwaN54FAd6GPrE9NSZbzWiJKDEAY8ugcG/EPRe9l6pdRQ9M6srTgBRWlmnXGiMGEwTnFJCAHN0KCJk6uaM/AmooBAqTLVpKJPGkuVEdG541B0Ioo29jAUc50G3ioDbyI6KVCqzBAGetl6Id2cntJDRomiYdeuXXj44YdhGAZmzJiBOXPmhDxfWlqKl19+GbIsw+VyYfny5ejbty8A4MiRI3jwwQfxzTffQJIkrF+/Hv369YvFYZyRV/dAFzoUk8Kh6EQUVQzGKao6C7wzzZmwyBaosgpFUhh4E1EIliojij5d17Fs2TKUlpbC7XajpKQERUVFGDhwYHCbSy65BK+88gpsNhteeOEFPPbYY3j88ccBAIsWLcJPfvITjBw5Ek1NTTCZ4iPIPXUoero5tVZFJ6L4wG8yFHGaocFreKF6VLRoLQy8ieis6Ibu7zuU6JYqIyKgoqICAwYMQH5+PgBg4sSJKC8vDwnG25dLu/zyy/H6668DAD7//HNomoaRI0cCAByO2K9uqLd9J5EgIc2cBqfqhCqrsW4WEaUoBuMUET7DB5/hg2EYsCgW9LL2Qt+svjiBEwy8o+znhf2QkZEJwBvrphCdFSEEWvQWSEKC2+6G0+yM6/6D1xolo5qaGuTl5QV/d7vdqKioOOP2W7ZswejRowEAlZWVSE9Px7x583D48GFcffXVWLBgAWQ5+tUOAkPRZUlGtjWbQ9F76BdXZCAtPQ1Aa6ybQpQUGIxT2PgMH7y6F0KIYABuVazB1Y3Nsjmuv0gnq4ty7MjOTmPtY0oo8VCq7GzxWqNUt23bNuzbtw+bNm0CAGiahj179uC1115D79698Ytf/AJbt27FjBkzzvgasiwjOzu70/dptcj49jsZmekZnW5nwECrz7/GRIY5B5nWTA5FP0f/kgUoigJNs8W6KanHMKAYRpfXByUWBuN0ToIBOAQssgU5thzYVBtUE4d8xYsPD51A+jHg4sxYt4Soa/FUquxs8VqjZOR2u1FdXR38vaamBm63+7Tt3nvvPaxbtw6bNm2C2ey/bvPy8nDJJZcEh7iPGTMGn3zySafvp+t6lze0PI3HYRg6jh0/3vFrnDIUPU1Ng+pT0eJrQQtaOn1t6tyH1R4405y41OGLdVNSj2Egy+Ho8vro3bt3lBpE4cDxOXTWfLoPTb4mNPoaIUFCji0HA9IHID8tH+mWdAbicWbjh9VY+/bBWDeDqFOGMNDka4JhGOjj7IPezt4JFYgDvNYoORUUFKCyshJVVVXwer0oKytDUVFRyDb79+/H0qVLsXbt2pCsXUFBAU6cOIG6ujoAwAcffBAy1zzcvLoHLVozdKEj25qNvs6+yLJmcU54GJXub8Daj7+LdTOIkgYz49QtPt1fe1NAwCpbkWvLhVW1MvAmonPWorXAEAaybdksVUYUZxRFwdKlSzF79mzouo7p06dj0KBBWL16NYYOHYoxY8bg0UcfRXNzM+bPnw/An5lbt24dZFnGokWLcPvttwMAhgwZ0ukQ9Z4QwoDH8MAwDNgUG3pZenEoOhElDAbjdEaBABwALLIFubZc2FQbywkRUVj4dB9ajVZkmDP82Sve3COKS4WFhSgsLAx5LBB4A8DGjRvPuO/IkSOxffv2sLfJEAZa9Gauik5ECS2i6Yddu3ZhwoQJGDduHNavX3/a80eOHMGPf/xjTJkyBZMmTcLbb7992vNXXHEFnnnmmUg2k9rx6t7gEHTZJCPXlosB6QPQL60f0ixpDMSJ6Jzpho4mbxMgAf2c/ZBrz2UgTkTdJkkSrLKNQ9GJKOFFLLLSdR3Lli1DaWkp3G43SkpKUFRUFDJXaO3atbjhhhtwyy234PPPP8ecOXOwc+fO4PMrVqzAqFGjItVEauPVvfAZPggI2BU7sm3ZsMgWBt5E3bBr1y48/PDDMAwDM2bMwJw5c07b5o033sCaNWsgSRIuvvhirFq1Cv/4xz/wm9/8Bo2NjTCZTJg7dy6Ki4tjcATR075UWa49N+5LlRFRfDLLZmSn90G9j4uIUZgJcfK/Hf3c2TZtpFO3P1W7v/fEKdt1+Teiy9XVFpRgIhZtVVRUYMCAAcEVNCdOnIjy8vKQYFySJDQ2NgIAGhoakJubG3zurbfeQt++fWG32yPVxJQlhPCvgt620qhNsSHblg2rbE2I8kF0dhaN6Y/MzEywJmj4deemY2VlJdavX48XX3wRGRkZwVVQrVYrVq5cifPOOw81NTWYPn06rrnmGqSnp8fqcCLKo3vg1b3IsmQhy5qVlH0NrzUiSnb3D89EekY6IJp79gJnG+x28LzUQQAcorNgV4iQ509jMgX/KwLbSVLwcWEyhWwTfK12j4vA44F/214j2JJTHj+rn7OzAZbPTCoRC8ZramqQl5cX/N3tdqOioiJkm3nz5uGuu+7Cpk2b0NLSgtLSUgBAU1MTnn76aTz77LN49tlnI9XElCKEgNfwQjM0AIBdtTMATxEDsqzIznagtpYBQrh156bj5s2bMXPmTGRk+OvhBlYaPv/884PbuN1uuFwu1NXVJV0wrhkaWvVW2BQb8hx5sMiWWDcpYnitEVHSEgLw+XCeoiFT9uLY8SZ/gBkIlNuCxbMKdoHQoFWS/IFsYLtTg93Afh0Fw50Fu6e+T0ePt3+MKIpiOg65rKwMU6dOxZ133om9e/di4cKF2LFjB9asWYPbb78dDoej268ly3JIOY2OCCFw4sQJOLOc59r0hCCE8A9BFz5AAC6zCxmWDFiV2ATgiqJ0+RlR+O3853eQ62pROIjnPty6c9OxsrISAPDDH/4QhmFg3rx5GD16dMg2FRUV8Pl86N+/f8TbHC2GMNCitUCRFPRx9IFdTf5RTu98eQzp3xkYlsPV4IkowWkaoGmQdB0C/tGshs2GXSdUpJkdGNbH0bMMLxGFiFgw7na7UV1dHfy9pqYGbrc7ZJstW7Zgw4YNAIArrrgCHo8H9fX1+OSTT/DnP/8Zv/vd73DixAmYTCZYLBbceuutZ3w/XdeDwz/PRAgBTdJQ31R/DkcW34IZcF2DJEmwq3akm9NhkS2QvTJava1ojdEQyuzs7C4/Iwq/p97+HKqqYmg3phn17t078g1KMbqu46uvvsLzzz+P6upq3Hrrrdi+fXswA/7tt9/ivvvuw8qVK2EydR7Edeemo2ZoaDrRFNObji2+FuhCR197X2RaM1OmVNmWbQchScfw/KzvxbopKYk3fIl6qC3rLWla8HehqhBOJ4TNBqGqgKoCkoQX3j0AVW3F6snnd/6aRNQtEQvGCwoKUFlZiaqqKrjdbpSVlWHVqlUh2/Tu3Ru7d+/GtGnT8MUXX8Dj8cDlcuGFF14IbvPEE0/Abrd3GoinulMDcIfqQJotDVbFmjJfgolioTs3Hd1uN4YNGwZVVZGfn4/zzjsPlZWVuOyyy9DY2Ii7774bv/jFL3D55Zd3+X7duemoGRo0k4b6E9G/6RgoVZZuTofL6oJoFqhvTt6bn6fy+XxQVZU3HWOkuzd8edORUt4Zst4iM9MfeJvNgMwpjETRELFgXFEULF26FLNnz4au65g+fToGDRqE1atXY+jQoRgzZgzuv/9+PPjgg9i4cSMkScKKFSu4sm43CSHg0T0whAEAcJqdcNqdsMoMwImipTs3HceOHYuysjJMnz4ddXV1qKysRH5+PrxeL+655x5MnjwZ119/fYyOIDx0Q0er1gqzYkY/Zz/YFFusm0RERMBZZb2JKPoiOme8sLAQhYWFIY/Nnz8/+PPAgQPx0ksvdfoaP/vZzyLStkQUCMB1oQMA0sxpcJoZgBPFSnduOo4aNQrvvvsuiouLIcsyFi5ciKysLGzbtg179uzBsWPH8OqrrwLwl3O85JJLYnxU3SeEQKveCiEEcuw5SDOn8YYqEVEsnSnrnZEBYTYz600UZ1hIOs4ZwoBX90IXOiRISDOnwWF2MAAnihNd3XSUJAmLFy/G4sWLQ7aZPHkyJk+eHJU2RoJH98Cn+5BpyUSmNROKiX+dEBFF1alZb8OAMJuZ9SZKIPz2FIcMYQSHoEuQkG5Oh8PsgEW2MACns/bQhPOQlZUFaE2xbgolgVQqVXa2eK0RUUTFQdab/RxReDEYjxNnCsCtspXDPumcuNPMyM6woraWf3FSzwkh0Kw1Q5Zk5Nnz4FAd7JtOwWuNiMImTrPe7OeIwovBeAy1D8BNksk/BF1lAE7h9daBOjidPlzVR411UyhBtWgtMIQBl9WFDEsGR+icAa81IuqxOMh6dwf7OaLwYjAeZe0DcFmSkW5Oh121MwCniNlacRSqehxXsSYonSWf7oPH8MCpOuGyumCWzbFuUlzjtUZE3RKnWe/uYD9HFF4MxqNAN3R4Df8ibIqk+Iegq/454AzAiSjeGMJAs9YMs2xGH2cf2BV7rJtERJS42me9hYBkMsVl1puIoo/BeIS0D8BVSWUATkRxr32pslxbLkuVERGdLSH8gbfP5/89gbLeRBR9DMbDSDd0/xB0GFAlFRnmDNhVOwNwIop7Xt0Lj+5BpiUTWdYsliojIuqOM2W909OZ9SaiLvHb1jkKBOACAoqkIMuaBbtqh9lkZgBORHFPMzR4dA8ssgX5afmwKtZYN4mIKD4x601EYcZgvAc0Q4NX9/oz4CaVATjFteUTL0BWVhZEa0Osm0JxpH2pMrfdzVJlYcBrjSjJMOt9GvZzROHFYLybNEOD1/DCEP4A3GVzwabYYJEtsW4aUacybQpcDjNqW2PdEooXrVorNKEhy5KFTEsmZFNqfZmMFF5rRAmsfdZbCEAIZr07wH6OKLwYjHciEIALIaDKKlxWF+yKneV9KKGU7a+F0+lBYX/eOEp1PsMHj+aBQ3Wgj60P+7Iw47VGlECY9e4R9nNE4cVg/BTBDLhhwKJYGIBTwivbXwtVPYHC/qwJmqoCpcpUk4o+aSxVFim81ojiFLPeYcN+jii8GIzDny3yGb5gAN7L2gtWxcoAnIgSWqBUmSEM9LL1Qro5HSbJFOtmERFFlq4DPh+z3kQU91I2GPcZPnh1/xD0QABuU21QTWqsm0ZEdM5YqoyIUgKz3kSUwCL67WzXrl14+OGHYRgGZsyYgTlz5oQ8f+TIESxatAgNDQ3QdR0LFixAYWEhKioq8Otf/xqAP7Pzs5/9DOPGjQtbuxp9jbDIFuTYchiAE1FSkiSJpcqIKHnpOtDYyKw3ESW0iAXjuq5j2bJlKC0thdvtRklJCYqKijBw4MDgNmvXrsUNN9yAW265BZ9//jnmzJmDnTt3YtCgQXjllVegKAq+/fZbTJ48Gddddx0U5dyaK0kS+qX3Q7qRzgCciJKSLMnol94PzaKZpcqIKDmZzUD//jBOnGDWm4gSWsSC8YqKCgwYMAD5+fkAgIkTJ6K8vDwkGJckCY2NjQCAhoYG5ObmAgBsNltwG4/HE9YvlHbVjhZTS9hejyje/X7yQLhcLjQ3HIt1UygKJEny93MS+7lo47VGFCUmE+BwAK2srxVt7OeIwitiwXhNTQ3y8vKCv7vdblRUVIRsM2/ePNx1113YtGkTWlpaUFpaGnzuk08+wZIlS3DkyBE8+uij55wVJ0pVVtUEm1lGc6wbQpTkeK0RUbJjP0cUXjGNcMvKyjB16lTceeed2Lt3LxYuXIgdO3bAZDJh2LBhKCsrwxdffIFFixZh9OjRsFjOXNNQlmVkZ2d3+Z6KonRrOwo/nvvY+MOHVTAdbMWPhveNdVOIktorn3wHh7MZ11/I0nFElJzYzxGFV8SCcbfbjerq6uDvNTU1cLvdIdts2bIFGzZsAABcccUV8Hg8qK+vDwnYLrzwQtjtdhw4cAAFBQVnfD9d11FbW9tlu7Kzs7u1HYUfz31svL73MFRVxfjzu17Iq3fv3lFoEVFyKv+sHqraiOsvZP1dIkpO7OeIwitiBWcLCgpQWVmJqqoqeL1elJWVoaioKGSb3r17Y/fu3QCAL774Ah6PBy6XC1VVVdA0DQDw9ddf48svv0TfvszqERERERERUXKIWGZcURQsXboUs2fPhq7rmD59OgYNGoTVq1dj6NChGDNmDO6//348+OCD2LhxIyRJwooVKyBJEj7++GM8/fTTUBQFJpMJv/nNb+ByuSLVVCIiIiIiIqKoiuic8cLCQhQWFoY8Nn/+/ODPAwcOxEsvvXTaflOmTMGUKVMi2TQiIiIiIiKimInYMHUiIiIiIiIi6hjrhREluSdLLuLieURRwGuNiJId+zmi8GJmnIiIiIiIiCjKGIwTEZ2DXbt2YcKECRg3bhzWr1/f4TZvvPEGiouLMXHiRPzqV78KPv7qq69i/PjxGD9+PF599dVoNZmIiIiI4gCHqRMR9ZCu61i2bBlKS0vhdrtRUlKCoqIiDBw4MLhNZWUl1q9fjxdffBEZGRnBoX3Hjh3DmjVr8Morr0CSJEybNg1FRUXIyMiI1eEQEXVo165dePjhh2EYBmbMmIE5c+aEPF9aWoqXX34ZsizD5XJh+fLlISVpGxsbUVxcjLFjx2Lp0qXRbj4RUdxiZpyIqIcqKiowYMAA5Ofnw2w2Y+LEiSgvLw/ZZvPmzZg5c2YwyM7OzgYA/M///A9GjhyJzMxMZGRkYOTIkXjnnXeifgxERJ0J3HTcsGEDysrKsGPHDnz++ech21xyySV45ZVXsH37dkyYMAGPPfZYyPOPP/44rrzyymg2m4goITAYJyLqoZqaGuTl5QV/d7vdqKmpCdmmsrISBw8exA9/+EPcdNNN2LVrV7f3JSKKte7cdLzqqqtgs9kAAJdffjmqq6uDz+3btw+1tbUYOXJkVNtNRJQIOEydiCiCdF3HV199heeffx7V1dW49dZbsX379h69lizLwcx6ZxRF6dZ2FH4897HDcx8ZHd04rKioOOP2W7ZswejRowEAhmFg5cqVeOyxx/Dee+9FvK1ERImGwTgRUQ+53e6QDFBNTQ3cbvdp2wwbNgyqqiI/Px/nnXceKisr4Xa78eGHH4bsO2LEiE7fT9f1bpWTYdmZ2OG5j53unvvevXtHoTWpadu2bdi3bx82bdoEAHjhhRcwevTokGC+K7zpGP947mOH5z75MBgnIuqhgoICVFZWoqqqCm63G2VlZVi1alXINmPHjkVZWRmmT5+Ouro6VFZWIj8/H/3798fvf/97HD9+HIB/Dvkvf/nLWBwGEdEZdeemIwC89957WLduHTZt2gSz2QwA2Lt3Lz7++GO8+OKLaGpqgs/ng91ux4IFC874frzpGP947mOnO+eeNxwTC4NxIqIeUhQFS5cuxezZs6HrOqZPn45BgwZh9erVGDp0KMaMGYNRo0bh3XffRXFxMWRZxsKFC5GVlQUA+OlPf4qSkhIAwD333IPMzMwYHg0R0em6c9Nx//79WLp0KTZs2BCStWu/3datW7Fv375OA3EiolQjCSFErBtBRERERPHp7bffxvLly4M3HefOnRty0/GOO+7AgQMHkJOTA8CfmVu3bl3IawSCcZY2IyI6icE4ERERERERUZSxtBkRERERERFRlDEYJyIiIiIiIooyBuNEREREREREUcZgnIiIiIiIiCjKGIwTERERERERRVlCBeMnTpzAvffei+uvvx433HAD9u7dG3zu2WefxeDBg1FXVxd8zOfzYerUqfjmm2/w4x//GMXFxZg4cSKee+654DbHjh3DrFmzMH78eMyaNQvHjx8/bX8A2LVrFyZMmIBx48Zh/fr1UTja2In381xaWori4mJMmjQJt99+O77++utwn4KYifdzH/DnP/8ZgwcPxqeffhquQyckzuefDOL9XLOfi/3/5+znIiNRPv9kEO/nmv1c7P8/Zz8XB0QCWbhwodi8ebMQQgiPxyOOHz8uhBDiyJEj4s477xTXXnutqK2tDW6/e/dusWzZMlFTUyP27dsnhBCioaFBjB8/Xnz22WdCCCFWrlwpnnrqKSGEEE899ZR49NFHT9tf0zQxZswYcejQIeHxeMSkSZOC+yejeD/Pu3fvFs3NzUIIIf7whz+I+fPnh/8kxEi8n/vA699yyy1ixowZoqKiIvwnIYUlwuefLOL9XLOfYz+XrBLh808W8X6u2c+xnyMhEiYz3tDQgI8++gglJSUAALPZjPT0dADAI488gvvuuw+SJIXs884772D06NHIzc3FkCFDAABOpxMXXHABampqAADl5eWYMmUKAGDKlCl46623Ttu/oqICAwYMQH5+PsxmMyZOnIjy8vJIH3JMJMJ5vuqqq2Cz2QAAl19+Oaqrq8N7EmIkEc49AKxevRr/+q//CovFEtbjT3WJ8vkng0Q41+znTmI/lzwS5fNPBolwrtnPncR+LnUlTDB++PBhuFwuLF68GFOmTMEDDzyA5uZmvPXWW8jNzcXFF1982j4ffPABRowYcdrr/OMf/8CwYcMAALW1tcjNzQUA5OTkoLa29rT9a2pqkJeXF3zc7XYHL4xkk2jnecuWLRg9enSPjzeeJMK5//vf/47q6mpce+214ThkaicRPv9kkWjnmv0c+7lkkQiff7JItHPNfo79XKpKmGBc0zTs378fP/rRj/Daa6/BZrPhiSeewFNPPYX58+eftn1NTQ0yMjKCd9wAoKmpCffeey+WLFkCp9N52j6SJAXvVHW0fypIpPO8bds27Nu3D7Nnzz7rfeNRvJ97wzCwYsUKLFq0qIdHSJ2J988/mSTSuWY/x34umcT7559MEulcs59jP5fKEiYYz8vLQ15eXvDu0PXXX4/9+/fj8OHDmDx5MoqKilBdXY1p06bhu+++w65duzBq1Kjg/j6fD/feey8mTZqE8ePHBx/Pzs7Gt99+CwD49ttv4XK5ACBkf7fbHTJ0pqamBm63O+LHHAuJcp7fe+89rFu3DmvXroXZbA7vSYiReD/3TU1NOHDgAG677TYUFRXhb3/7G+bOnctFP8Ik3j//ZJIo55r9HPu5ZBPvn38ySZRzzX6O/VyqS5hgPCcnB3l5efjyyy8BALt378all16K3bt3Y+fOndi5cyfy8vKwdetW5OTk4J133gn+jymEwAMPPIALLrgAs2bNCnndoqIivPbaawCA1157DWPGjAGAkP0LCgpQWVmJqqoqeL1elJWVoaioKEpHHl2JcJ7379+PpUuXYu3atcjOzo7UqYi6eD/3aWlp+OCDD4Jtufzyy7F27VoUFBRE8rSkjHj//JNJIpxr9nPs55JRvH/+ySQRzjX7OfZzhMRaTX3//v1i6tSp4sYbbxRz584Vx44dC3n+uuuuE7W1tULTNDF58uTg4x999JG46KKLxI033ih+8IMfiB/84Afir3/9qxBCiLq6OnHbbbeJcePGidtvv13U19eftr8QQvz1r38V48ePF2PGjBFPPvlkpA81puLxPD/++OPirbfeEkIIcfvtt4urr746+B533313ZE5EDMT7uW/v1ltv5eqbYRaPn3+yisdzzX7OL9bnvj32c+EXj59/sorHc81+zi/W57499nOxlVDBeHd99NFH4te//nXM9k8VPM+xw3Of2vj5Rw/Pdezw3Kc2fv7Rw3MdOzz3JAkhRKyz80RERERERESpJGHmjBMRERERERElCwbjRERERERERFHGYJyIiIiIiIgoyhiMExEREREREUWZEusGUHy75JJLcNFFF0HTNMiyjClTpuCOO+6AyRSb+zgbN27EzTffDJvNFpP3J6Lkw36OiJId+zmi+MRgnDpltVqxbds2AEBtbS1+9atfobGxEffee2/IdpqmQVEi/7/Tf/3Xf+EHP/gBO28iChv2c0SU7NjPEcUnljajTl1xxRXYu3dv8PeqqiqUlJTg/fffx6uvvor//u//RnNzMwzDwJo1a7BkyRJUVVXBZrNh2bJluPjii/HEE0/g0KFDOHToEOrr6zF79mzcdNNNEELg0UcfxTvvvANJkjB37lwUFxfjgw8+wLPPPounnnoKALBs2TIMHToUjY2NePTRR3H++ecjMzMTzz//fKxOCxElEfZzRJTs2M8RxSdmxums5OfnQ9d11NbWAgD279+P119/HZmZmfjtb3+LSy+9FE8++SR2796NRYsWBe/C/t///R82b96M5uZmTJ06FYWFhfjb3/6Gf/7zn9i2bRvq6+tRUlKC4cOHn/G9b7vtNmzcuBHPPfccXC5XVI6XiFIP+zkiSnbs54jiAxdwo3MycuRIZGZmAgA+/vhjTJ48GQBw9dVX49ixY2hsbAQAjBkzBlarFS6XC//yL/+CTz/9FB9//DEmTpwIWZbRq1cvXHnllfj0009jdShERB1iP0dEyY79HFFsMBins1JVVQVZlpGdnQ0A3Z7rI0lSt99DlmUYhhH83ePxnF0jiYjOAfs5Ikp27OeI4gODceq2uro6PPTQQ5g5c2aHnfHw4cPx+uuvAwA++OADZGVlwel0AgDKy8vh8XhQX1+PDz/8EAUFBRg+fDj+9Kc/Qdd11NXVYc+ePbjsssvQt29ffPHFF/B6vThx4gR2794dfA+Hw4GmpqboHDARpRz2c0SU7NjPEcUPzhmnTrW2tmLy5MnBUhiTJ0/GrFmzOtx23rx5WLJkCSZNmgSbzYYVK1YEnxs8eDBuu+021NfX46c//SncbjfGjRuHvXv3YvLkyZAkCffddx9ycnIAANdffz1uvPFG9OvXD5deemnwdW666SbMnj0bubm5XPCDiMKC/RwRJTv2c0TxiaupU8Q98cQTsNvtuOuuu2LdFCKiiGA/R0TJjv0cUfhxmDoRERERERFRlDEzTkRERERERBRlzIwTERERERERRRmDcSIiIiIiIqIoYzBOREREREREFGUMxomIiIiIiIiijME4ERERERERUZQxGCciIiIiIiKKsv8HxkxDqfSMvLoAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1080x288 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "performances_df_nn_subset = performances_df_nn[performances_df_nn['Parameters'].apply(lambda x:x['clf__lr']== 0.001 and x['clf__module__hidden_size']==500 and x['clf__module__num_layers']==2 and x['clf__max_epochs']==20 and x['clf__batch_size']==64).values]\n",
    "summary_performances_nn_subset=get_summary_performances(performances_df_nn_subset, parameter_column_name=\"Parameters summary\")\n",
    "indexes_summary = summary_performances_nn_subset.index.values\n",
    "indexes_summary[0] = 'Best estimated parameters'\n",
    "summary_performances_nn_subset.rename(index = dict(zip(np.arange(len(indexes_summary)),indexes_summary)))\n",
    "get_performances_plots(performances_df_nn_subset, \n",
    "                       performance_metrics_list=['AUC ROC', 'Average precision', 'Card Precision@100'], \n",
    "                       expe_type_list=['Test','Validation'], expe_type_color_list=['#008000','#FF0000'],\n",
    "                       parameter_name=\"Dropout\",\n",
    "                       summary_performances=summary_performances_nn_subset)\n",
    "\n",
    "parameters_dict=dict(performances_df_nn['Parameters'])\n",
    "performances_df_nn['Parameters summary']=[str(parameters_dict[i]['clf__lr'])+\n",
    "                                   '/'+\n",
    "                                   str(parameters_dict[i]['clf__batch_size'])+\n",
    "                                   '/'+\n",
    "                                   str(parameters_dict[i]['clf__max_epochs'])+\n",
    "                                   '/'+\n",
    "                                   str(parameters_dict[i]['clf__module__p'])+\n",
    "                                   '/'+\n",
    "                                   str(parameters_dict[i]['clf__module__num_layers'])\n",
    "                                   for i in range(len(parameters_dict))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As for the dropout, it helps generalize and improve the valid/test metrics. However, when the dropout value is too high (0.4), it can deteriorate the results, e.g. by limiting the fitting power or by requiring a larger number of epochs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving of results \n",
    "\n",
    "Let us save the performance results and execution times of the neural network models in a Python pickle format. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "performances_df_dictionary={\n",
    "    \"Neural Network\": performances_df_nn\n",
    "}\n",
    "\n",
    "execution_times=[execution_time_nn]\n",
    "\n",
    "filehandler = open('performances_model_selection_nn.pkl', 'wb') \n",
    "pickle.dump((performances_df_dictionary, execution_times), filehandler)\n",
    "filehandler.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benchmark summary\n",
    "\n",
    "Let us finally retrieve the performance results obtained in [Chapter 5](Model_Selection_Comparison_Performances) with decision tree, logistic regression, random forest and XGBoost, and compare them with those obtained with a feed-forward neural network. The results can be retrieved by loading the `performances_model_selection.pkl` and `performances_model_selection_nn.pkl` pickle files, and summarized with the `get_summary_performances` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": [
     "hide-cell"
    ]
   },
   "outputs": [],
   "source": [
    "# Load performance results for decision tree, logistic regression, random forest and XGBoost\n",
    "filehandler = open('../Chapter_5_ModelValidationAndSelection/performances_model_selection.pkl', 'rb') \n",
    "(performances_df_dictionary, execution_times) = pickle.load(filehandler)\n",
    "\n",
    "# Load performance results for feed-forward neural network\n",
    "filehandler = open('performances_model_selection_nn.pkl', 'rb') \n",
    "(performances_df_dictionary_nn, execution_times_nn) = pickle.load(filehandler)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": [
     "hide-cell"
    ]
   },
   "outputs": [],
   "source": [
    "performances_df_dt=performances_df_dictionary['Decision Tree']\n",
    "summary_performances_dt=get_summary_performances(performances_df_dt, parameter_column_name=\"Parameters summary\")\n",
    "\n",
    "performances_df_lr=performances_df_dictionary['Logistic Regression']\n",
    "summary_performances_lr=get_summary_performances(performances_df_lr, parameter_column_name=\"Parameters summary\")\n",
    "\n",
    "performances_df_rf=performances_df_dictionary['Random Forest']\n",
    "summary_performances_rf=get_summary_performances(performances_df_rf, parameter_column_name=\"Parameters summary\")\n",
    "\n",
    "performances_df_xgboost=performances_df_dictionary['XGBoost']\n",
    "summary_performances_xgboost=get_summary_performances(performances_df_xgboost, parameter_column_name=\"Parameters summary\")\n",
    "\n",
    "performances_df_nn=performances_df_dictionary_nn['Neural Network']\n",
    "summary_performances_nn=get_summary_performances(performances_df_nn, parameter_column_name=\"Parameters summary\")\n",
    "\n",
    "summary_test_performances = pd.concat([summary_performances_dt.iloc[2,:],\n",
    "                                       summary_performances_lr.iloc[2,:],\n",
    "                                       summary_performances_rf.iloc[2,:],\n",
    "                                       summary_performances_xgboost.iloc[2,:],\n",
    "                                       summary_performances_nn.iloc[2,:],\n",
    "                                      ],axis=1)\n",
    "\n",
    "summary_test_performances.columns=['Decision Tree', 'Logistic Regression', 'Random Forest', 'XGBoost', 'Neural Network']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The results are summarized in a `summary_test_performances` table. Rows provide the average performance results on the test sets in terms of AUC ROC, Average Precision and CP@100. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Decision Tree</th>\n",
       "      <th>Logistic Regression</th>\n",
       "      <th>Random Forest</th>\n",
       "      <th>XGBoost</th>\n",
       "      <th>Neural Network</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>AUC ROC</th>\n",
       "      <td>0.797+/-0.01</td>\n",
       "      <td>0.868+/-0.02</td>\n",
       "      <td>0.87+/-0.02</td>\n",
       "      <td>0.869+/-0.01</td>\n",
       "      <td>0.876+/-0.01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Average precision</th>\n",
       "      <td>0.579+/-0.01</td>\n",
       "      <td>0.623+/-0.02</td>\n",
       "      <td>0.678+/-0.01</td>\n",
       "      <td>0.687+/-0.01</td>\n",
       "      <td>0.675+/-0.01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Card Precision@100</th>\n",
       "      <td>0.284+/-0.0</td>\n",
       "      <td>0.297+/-0.01</td>\n",
       "      <td>0.299+/-0.01</td>\n",
       "      <td>0.303+/-0.01</td>\n",
       "      <td>0.303+/-0.02</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   Decision Tree Logistic Regression Random Forest  \\\n",
       "AUC ROC             0.797+/-0.01        0.868+/-0.02   0.87+/-0.02   \n",
       "Average precision   0.579+/-0.01        0.623+/-0.02  0.678+/-0.01   \n",
       "Card Precision@100   0.284+/-0.0        0.297+/-0.01  0.299+/-0.01   \n",
       "\n",
       "                         XGBoost Neural Network  \n",
       "AUC ROC             0.869+/-0.01   0.876+/-0.01  \n",
       "Average precision   0.687+/-0.01   0.675+/-0.01  \n",
       "Card Precision@100  0.303+/-0.01   0.303+/-0.02  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summary_test_performances"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Overall, it appears that our simple feed-forward neural network is a good competitor in terms of predictive performance for the fraud detection problem, providing the best performances in terms of AUC ROC and CP@100, and competitive performances in terms of Average Precision. Moreover, it benefits from many advantages (e.g. its ability for incremental learning), as mentioned in the previous section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section gave an overview of how to design a feed-forward neural network for fraud detection. Comparatively to classical machine learning models, neural networks have an infinite set of hyperparameters. This modularity in the design has a lot of advantages in terms of expressivity but it comes at the cost of a time-consuming hyper optimization of the architecture, the activations, the loss, the optimizers, the preprocessing, etc. Nevertheless, there are many ways to automate hyper optimization and architecture design, for instance with AutoML including Neural Architecture Search (or NAS) {cite}`elsken2019neural`.\n",
    "\n",
    "Here only the top of the iceberg is covered. There are many other aspects to consider even with such a simple neural network. Many of them can be found in good practice guides and generally also apply to fraud detection. Some are even specific to problems like the latter. An important one is to manage imbalance (refer to Chapter 6 for more details): it can be done with neural networks by replacing binary cross-entropy with a weighted BCE (putting more importance on the loss terms associated with fraud samples) or with focal loss, a variant of cross-entropy specifically designed to automatically focus on under-represented samples. Another way is to implement a custom Dataloader with a [balanced sampler](https://github.com/ufoym/imbalanced-dataset-sampler).\n",
    "\n",
    "The rest of the chapter rather focuses on different types of neural network models like autoencoders or sequential models and the way they can be used in a fraud detection context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Tags",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
